As you probably know Italy is experiencing one of the worst periods of its recent history. The covid-19 epidemic has put the medical system on its knees and the lock down is severely testing the population’s self-control capabilities.
Open data for the covid-19 infection is available here https://github.com/pcm-dpc/COVID-19 and updated daily. These are numbers and as usual they need to be read, understodd. One of the questions I was asking my self is how the rate of positives compared to the number of tests done is moving. I made this chart :
The ordinate is the percentage of positive cases against the number of tests done each day. Spikes of 42% are probably due to differences of response times for the laboratories which currently do not guarantee a stable processing time for tests. This behavior could be that due to the test methodology being changed or simply because we are finding less people infected.
Another information that can be interesting is the number of daily people being treated with intensive care :
Again here we might be in a situation of saturation of Intensive care units or just the number of people being treated in intensive care is decreasing.
This is the behavior of the number of people being hospitalized
We use Teamcity for most of automation in building/testing/deploying golang microservices to prod and during test phase I wanted to be able to notice easily if an integration/benchmark test crashed a microservice. Pinning the build and tagging it with the word “panic” seemed to be a good idea, from inside the buildconf script :
# txt are are the microservice logfiles, substitute as neeeded
grep panic.go *.txt
retVal=$?
if [ $retVal -eq 0 ]; then
# grep found panic in some file, tag with panic
nohup sh -c 'sleep 10 ; curl --header "Origin: https://<your_tc_server>" --header "Authorization: Bearer <yourbearertoken>" --request POST "%teamcity.serverUrl%/app/rest/builds/id:%teamcity.build.id%/tags/" --data panic --header "Content-type: text/plain"' &
nohup sh -c 'sleep 10 ; curl --header "Origin: https://<your_tc_server>" --header "Authorization: Bearer <yourbearertoken>" --request PUT "%teamcity.serverUrl%/app/rest/builds/id:%teamcity.build.id%/pin/"' &
fi
Took more than expected to figure out this : some examples would be helpful. Note that the build needs to be finished to be able to pin it/tag it so we have to put this ugly sleep to postpone operations on the rest api when the build is finished.
Many time we face situation were productivity of a software team is impaired by initial flaws in system design. These initial flaws require too much time to be completely removed (the effort of complete rewrite is only marginally touched here and is normally and indication of other problems in your software project )
So, in order for a software team to be able to work at its maximum, good design is a must. Design is much more responsible for productivity than any single coder, scrum master, product manager or development methodology/language in the sense that bad design can take an all-star team using top tools/methodology to perform badly.
That kind of intellectual activity which creates a whole from its diverse parts may be called the design of a system
Melvin E. Conway, How Do Committees Invent?
So you compose parts to make the whole system. How you do this ?
It is basically decomposition to generate single parts that acting together will generate the goal. The 2 tools you will need as a designer are :
decomposition
composition
But first of all you need :
understanding of the system boundaries : the borders of the nation your system lives in
understanding the global scenario of what your system is going to do. Designing subsystems without knowing the whole picture is not a good idea.
Why decomposition of a system into smaller components (services) is good for you :
information hiding : well identified interfaces create a contract that the component has to provide, hiding any network/system implementation details. This will make the component implementation completely free to be modified/enhanced as long as the new implementation is compliant with the contract.
less development time : separate components/services can be developed in parallel since they don’t require (or require little) external dependencies, so less contention between engineers. Every component is independent on integration and performance test that can be developed autonomously.
scalability : with little effort in design every component might be deployed in a way to be one of many instances that will make that service scalable when traffic increases.
clarity : the system could be studied a component (service) at a time with the result that the whole system could be better designed because it was better understood
We could go on here and analyze what are the criteria to be used in decomposing a system into services. I’ll leave this to another moment and you can find some interesting notes here :
What I would like to stress is that design is a fundamental phase in software engineering. You can’t just skip it and pretend that since you have a good team you’ll get a good job done.
Thanks to the following for inspiring me on this post :
Go provides benchmarking features in the testing package which is pretty usefull :
func BenchmarkMd5EncodeFmt(b *testing.B) {
// run the md5Encode function b.N times
for n := 0; n < b.N; n++ {
Md5EncodeFmt("aldfhasdl la fasdfeo8ekldjh asdkj fh lksdjfhwoieuxnroiAUN;laiDJ;ANIfub;OEIRBUF;OEfuN;ALFJ;AL")
}
}
func BenchmarkMd5Encode(b *testing.B) {
// run the md5Encode function b.N times
for n := 0; n < b.N; n++ {
Md5Encode("aldfhasdl la fasdfeo8ekldjh asdkj fh lksdjfhwoieuxnroiAUN;laiDJ;ANIfub;OEIRBUF;OEfuN;ALFJ;AL")
}
}
Run
$ go test -bench=.
goos: linux
goarch: amd64
BenchmarkMd5EncodeFmt-8 1894791 625 ns/op
BenchmarkMd5Encode-8 3068509 363 ns/op
PASS
ok _/home/paul/LazyInit/bench 3.342s
Run 3 times the benchmarks :
$ go test -count 3 -bench=.
goos: linux
goarch: amd64
BenchmarkMd5EncodeFmt-8 1882105 627 ns/op
BenchmarkMd5EncodeFmt-8 1918942 624 ns/op
BenchmarkMd5EncodeFmt-8 1902894 625 ns/op
BenchmarkMd5Encode-8 3139585 386 ns/op
BenchmarkMd5Encode-8 2937154 397 ns/op
BenchmarkMd5Encode-8 3009801 380 ns/op
PASS
ok _/home/paul/LazyInit/bench 10.217s
EncodeToString() makes your method almost twice faster !
Thanks to god after year 2000 information technology has started moving towards more pragmatic, simple and effective tools and languages. Some examples that in my opinion make this evident :
Languages and language tools
go, rust, swift are all born with the goal of simplifying their direct parents (c++, objectiveC) and removing their pitfalls.
UML abandoned : this is a relief for all coders which had to deal with it. I don’t know anyone using it nowadays.
git : finally some one (thanks Linux Torvalds) simplified svn/sourcesafe by putting features that are needed by developers in a clear, pretty intuitive command line interface
atom/sublime : reaction to the complexity of Visual Studio, IBM Rational, Eclipse ? I think yes
Databases
Key-value stores/noSQL are just taking ER/SQL model and making it simpler, providing only the features needed in 99% of the applications. Boyce-Codd normal form is pretty nice and interesting but in real world applications you’ll never use it.
Object Databases completely disappeared and in some way also the idea that OO methodology/hierarchy could be applied everywhere (just because you are where using OO languages)
Virtualization
docker/rkt are slim alternatives to virtualization and virtual machines
Architectures
plain old REST API aren’t just a simple way for doing things without having to Corba/Soap ?
gRPC : provides corba like features while being 1 order of magnitude more efficent and portable on any platform.
What I’m saying is that the 90s produced a lot of unnecessarily complicated tools and technology which developer just did not need/like which is being progressively substituted with simpler stuff.
Interesting to note that the phrase “Less is more” is originally attributed to Mies Van Der Rohe for his minimalism in architecture design . Looks at his buildings : nothing more than necessary and functional elements are present.
Tiagra rear derailleur is often mounted on gravel bikes but I did not like its limit to 34 maximum cog size. My hackers attitude comes out in these situations (and I don’t care breaking the component warranty) so I decided to modify the derailleur to hold larger cogs.
The problem is that the B-Screw is short and won’t allow you to increase the distanze between the lower cogs from the upper cassette. While some tutorial suggest to put a longer b-screw, I tried what can be seen below :
I used a chain pin and insert it to make the mechanical stop longer. Some thread blocker or resin to keep it still and you’re set.
