Software quality really IS free : https://www.stellman-greene.com/2006/03/29/quality-really-is-free/
Building a high performance JSON parser https://dave.cheney.net/high-performance-json.html
The Corrective Commit Probability Code Quality Metric : https://arxiv.org/pdf/2007.10912.pdf
We all know how much the apollo computer technology impacted on consumer technology : https://www.computerweekly.com/news/252466699/How-Apollo-11-influenced-modern-computer-software-and-hardware
Before Apollo computers were huge and filled whole rooms like this :
Apollo guidance system was this :
Space industry led the way to a complete new era of digital personal computers.
We are now in 2020 and we all saw the first launch of a manned private mission to Space Station : the SpaceX dragon capsule attacched to ISS and astronauts @AstroBehnken and @Astro_Doug used a docking interface on a touchscreen device (try it out here https://iss-sim.spacex.com ) to dock dragon.
So consumer/private technology is currently used in the space industry : the complete opposite of Apollo/GoToTheMoon era.
Think of this from a political point of view : there were times when the biggest achievements in technology were driven by US federal agencies, pouring public money into research, universities, private companies to reach unbelievable goals (go to the moon). Those investment has been around $280 billion of today money. This drove the country into years of technological leadership, leadership US is loosing against another country (china) which is doing exactly what US did during the 60s i.e. pouring money into the economy with state participated companies.
Its time for another “go to the moon” type of effort and the new moon is giving this planet sustainable energy for sustainable growth.
Some points to further investigate : the main idea is that early 2000 years started a reaction to (unnecessary) complexity :
start here : https://medium.com/better-programming/how-unix-works-everything-you-were-too-afraid-to-ask-f8396aeb2763
simple is better (worse is better) : https://blog.codinghorror.com/worse-is-better/ the point here is all about what is considered to be better. Some furher reading “what’s wrong with word simple“
Why use inheritance when a simple object will do : https://www.philweber.com/2002/11/is_inheritance_overrated
optimism in coding is dangerous : https://blog.codinghorror.com/defeating-optimism/
worse is better : https://www.dreamsongs.com/Files/WorseIsBetterPositionPaper.pdf
worse is better http://wiki.c2.com/?WorseIsBetter
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
Image optimization and compression is one of main features of ImageEngine CDN (I work on this project). This Netflix blog article is great at going into details of why we probably need a new, modern image format : “AVIF for Next-Generation Image Coding” https://netflixtechblog.com/avif-for-next-generation-image-coding-b1d75675fe4
Faster Paint Metrics with Responsive Image Optimization CDNs
https://medium.com/@firt/faster-paint-metrics-with-responsive-image-optimization-cdns-d43340d4a48c
Speed up Woocommerce with an Image CDN https://hackernoon.com/speed-up-woocommerce-with-an-image-cdn-kt1q3yeg
Faster Image delivery with Chrome Light mode https://medium.com/imageengine/faster-image-delivery-with-chromes-lite-mode-93900eac126e
How to Reduce the Carbon Footprint of Your Website by 50% https://imageengine.io/blog/how-to-reduce-the-carbon-footprint-of-your-website-by-50/
Images are not static content https://css-tricks.com/images-are-not-static-content/
Prepare for the Ultimate Gaslighting https://forge.medium.com/prepare-for-the-ultimate-gaslighting-6a8ce3f0a0e0
Python package formats : it’s hard to keep track of them 🙂 https://www.bernat.tech/pep-517-and-python-packaging/
Always though that variables shadowing was a problem : https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#shadowing
and I still thinks so : https://mail.mozilla.org/pipermail/rust-dev/2013-May/004306.html
Microservice design : brokerless vs. broker/message bus based, interesting read
Nice dependency injection in Go : https://medium.com/@fsufitch/dependency-injection-and-testability-in-a-go-webservice-a91d0e5469dd
API Gateways : https://konghq.com/ https://tyk.io/
Goroutines in go 1.13 how they work : https://medium.com/a-journey-with-go/go-what-does-a-goroutine-switch-actually-involve-394c202dddb7
Monitoring air quality : http://www.esa.int/Applications/Observing_the_Earth/Copernicus/Monitoring_air_quality_takes_next_step
Spotify Engineering culture : https://medium.com/productmanagement101/spotify-squad-framework-part-i-8f74bcfcd761
QUIC : https://quicwg.org/base-drafts/draft-ietf-quic-http.html
Teamcity REST API : https://confluence.jetbrains.com/display/TCD10/REST+API
Object-Oriented Programming — The Trillion Dollar Disaster https://medium.com/better-programming/object-oriented-programming-the-trillion-dollar-disaster-92a4b666c7c7
Stop using classes in JS : https://medium.com/javascript-in-plain-english/please-stop-using-classes-in-javascript-and-become-a-better-developer-a185c9fbede1
Interesting read about latency and how 99% Quantile may not be enough : https://bravenewgeek.com/everything-you-know-about-latency-is-wrong/
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/"' &
fiTook 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.
There were times when it was taken for granted that before building a system, it was necessary to design it. That time looks gone (even though Agile does not explicitly prohibit making good design). The general idea seems to be that there is “never enough time to do something right, but there’s always enough time to do it over” again.
But what is design in software ?
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 :
But first of all you need :
Why decomposition of a system into smaller components (services) is good for you :
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 :
https://en.wikipedia.org/wiki/Melvin_Conway
Let’s say that you want to know if EncodeToString is faster than fmt.Sprintf : you will need to compare the speed of this method
func Md5Encode(str string) string {
md5HashInBytes := md5.Sum([]byte(str))
md5HashInString := hex.EncodeToString(md5HashInBytes[:])
return md5HashInString
}
with this other one
func Md5EncodeFmt(str string) string {
md5HashInBytes := md5.Sum([]byte(str))
md5HashInString := fmt.Sprintf("%x", md5HashInBytes)
return md5HashInString
}
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 !