[containers.gitbook.io] Build Containers the Hard Way

 https://containers.gitbook.io/build-containers-the-hard-way/

This guide is geared towards anyone interested in learning the low-level details regarding how to build containers. This guide is not intended for those who wish to learn to build container images with high-level tools like Docker.

At the end of this guide, you should understand the internals of a container image, how to construct a container image, and how to push a container image to a Docker container registry piece-by-piece.

rajivprab.com: Myths Programmers Believe about CPU Caches

https://software.rajivprab.com/2018/04/29/myths-programmers-believe-about-cpu-caches/

As a computer engineer who has spent half a decade working with caches at Intel and Sun, I’ve learnt a thing or two about cache-coherency. This was one of the hardest concepts to learn back in college – but once you’ve truly understood it, it gives you a great appreciation for system design principles.

You might be wondering why you as a software developer should care about CPU cache-design. For one thing, many of the concepts learnt in cache-coherency are directly applicable to distributed-system-architecture and database-isolation-levels as well. For instance, understanding how coherency is implemented in hardware caches, can help in better understanding strong-vs-eventual consistency. It can spur ideas on how to better enforce consistency in distributed systems, using the same research and principles applied in hardware.

InfoQ: Containers in 2019: They're Calling it a [Hypervisor] Comeback

https://www.infoq.com/articles/containers-hypervisors-2019/

• Near the close of 2018, Amazon amped up an already-increasing interest level in the marrying of container and hypervisor technology by announcing Firecracker, a Rust-based Virtual Machine Monitor
• Around the midpoint of this year, Weaveworks introduced a new project, Ignite, which wraps Amazon’s Firecracker project with a container-lifecycle UI experience.
• One clear use case for this new marriage of hypervisor technology and containers is to add a layer of protection and isolation to potentially sensitive (or untrusted) workloads.
• User experience is also important within the hypervisor/container space: a growing number of companies, developers, and open source projects have become dependent on the simple life-cycle and user experience that Docker brought to the container world. 
• Providing “isolation flexibility” within container orchestration frameworks like Kubernetes is becoming increasingly important. Can and will we have a world where clusters can provide dynamic choice based on workload type? The answer is yes!

torbjorn gannholm: The perfect programming language

https://cygni.se/the-perfect-programming-language/

I have always held that the act of programming is something that is done in an abstract realm and only later translated into a programming language. That programming should involve much more thinking than actual writing.

I mostly still stand by that but my years as a readability reviewer at Google raised my awareness of the fact that it takes time and practice to use a language well. Many were the hopeful C++ programmers who wrote fully functional and reasonably object-oriented code in Java but with a heavy C++ accent that couldn't quite meet the bar of elegance in Java (even if a C++ programmer might think it mostly elegant apart from the "flaws" of Java).

So how much does the choice of programmimg language matter? Is there or could there be a language that could be considered perfect?

Jacob Kaplan-Moss: How to Ace a Technical Interview

https://speakerdeck.com/jacobian/how-to-ace-a-technical-interview

Jacob Kaplan-Moss: My Python Development Environment, 2020 Edition

https://jacobian.org/2019/nov/11/python-environment-2020/#atom-entries

My setup pieces together pyenv, poetry, and pipx. It’s probably a tad more complex than is ideal for most Python users, but for the things I need, it’s perfect.

mnot.net "How Multiplexing Changes Your HTTP APIs"

https://www.mnot.net/blog/2019/10/13/h2_api_multiplexing?utm_source=dlvr.it&utm_medium=twitter

" HTTP/2 should put to rest any notion of the need to minimise the number of requests for APIs; the protocol makes them cheap enough to not practically matter. Go ahead and design a highly granular HTTP API to meet the needs of your clients. "

Tyk.io REST was NEVER about CRUD

https://tyk.io/blog/rest-never-crud/

A popular myth is that REST-based APIs must be CRUD-based – that couldn’t be further from the truth. It is simply one pattern in our API design toolbox.

This article outlines a variety of additional patterns available for REST-based APIs. The intent isn’t to be fully exhaustive, but to open the options for API designers uncertain about how to apply designs beyond CRUD to REST-based APIs.

lya Grigorik : Don't "Push" Your Pull Requests

https://www.igvita.com/2011/12/19/dont-push-your-pull-requests/

There is nothing more frustrating than to read the threads, or even worse, be on the receiving end of this experience gone wrong. The contributor is wounded because they are not recognized, and the maintainer is caught in a dilemma: they want to build and foster their community, but they have to dig-in against their biggest fans. There is no winner here and neither side is to blame.
Next time, before you dive into the editor, open a discussion, outline your problem and solution, and offer to do the work - don't "push" the pull request, and don't work in the dark.

InfoQ: Getting to Know Graal, the New Java JIT Compiler

https://www.infoq.com/articles/Graal-Java-JIT-Compiler
Oracle recently announced the first release of GraalVM, a research project that may in time lead to a replacement for HotSpot in its entirety.
For Java developers, Graal can be thought of as several separate but connected projects - it is a new JIT compiler for HotSpot, and also a new polyglot virtual machine. We will refer to the JIT compiler as Graal and the new VM as GraalVM.
The overall aim of the Graal effort is a rethinking of how compilation works for Java (and in the case of GraalVM for other languages as well).

Web: Single Page Application Is Not a Silver Bullet

Seva Zaikov - Single Page Application Is Not a Silver Bullet:



Single-page applications are everywhere. Even blogs, simple html pages (in the beginning something like https://danluu.com/), have turned into big fat monsters – for example, jlongster’s blog has 1206 stars at the moment of writing, and not because of the content (people usually subscribe to blogs rather than star the source): the only reason is that once he implemented it using React & Redux. What is the problem, though? He wants, he makes it, no questions here. The problem is that it is considered normalto make blogs for reading so bloated – of course, there are some people who complain, but the general response is utterly positive. But who cares about blogs – the problem is that nowadays pretty often question is not “to SPA or not to SPA”, rather “which client-side framework should we use for our SPA”.



'via Blog this'

Choosing an HTTP Status Code — Stop Making It Hard – Racksburg

Choosing an HTTP Status Code — Stop Making It Hard – Racksburg:



'via Blog this'

Why Raspberry Pi isn't vulnerable to Spectre or Meltdown - Raspberry Pi

Why Raspberry Pi isn't vulnerable to Spectre or Meltdown - Raspberry Pi: "Over the last couple of days, there has been a lot of discussion about a pair of security vulnerabilities nicknamed Spectre and Meltdown. These affect all modern Intel processors, and (in the case of Spectre) many AMD processors and ARM cores. Spectre allows an attacker to bypass software checks to read data from arbitrary locations in the current address space; Meltdown allows an attacker to read data from arbitrary locations in the operating system kernel’s address space (which should normally be inaccessible to user programs).

Both vulnerabilities exploit performance features (caching and speculative execution) common to many modern processors to leak data via a so-called side-channel attack. Happily, the Raspberry Pi isn’t susceptible to these vulnerabilities, because of the particular ARM cores that we use.

To help us understand why, here’s a little primer on some concepts in modern processor design. We’ll illustrate these concepts using simple programs in Python syntax like this one..."



'via Blog this'

GitHub - jwasham/coding-interview-university: A complete computer science study plan to become a software engineer.

GitHub - jwasham/coding-interview-university: A complete computer science study plan to become a software engineer.: "This is my multi-month study plan for going from web developer (self-taught, no CS degree) to software engineer for a large company.



This is meant for new software engineers or those switching from software/web development to software engineering (where computer science knowledge is required). If you have many years of experience and are claiming many years of software engineering experience, expect a harder interview.

If you have many years of software/web development experience, note that large software companies like Google, Amazon, Facebook and Microsoft view software engineering as different from software/web development, and they require computer science knowledge.

If you want to be a reliability engineer or operations engineer, study more from the optional list (networking, security)."



'via Blog this'

Serverless and Deployment Issues – Paul Johnston – Medium

Serverless and Deployment Issues – Paul Johnston – Medium:

Currently, deployment tools give us monolithic deployment scenarios for Serverless.

This is unfortunate, but a direct consequence of utilising tools that aren’t built for a Serverless deployment.

We’re in a bit of a waiting phase before someone develops much more granular deployment tools.

Until
we have tools and infrastructure providers that allow us to do things
like blue/green and canarying on functions in a relatively simple way,
then we’re going to have to roll our own tools to deliver this. It’s not
easy, but it’s what we’ve been doing for the last couple of years
anyway.

'via Blog this'

How I got to 200 productive hours a month

How I got to 200 productive hours a month: "When improving your productivity, don't expect it to increase in a week because the brain needs a lot of time to restructure to new behaviors. Instead, set a small performance goal like "get 5% better each month." Aiming for faster results will make you too stressed out, while productivity requires a calm mind and a well-rested body. Be tough on your ineffective habits, but please be easy on yourself."



'via Blog this'

LinkedIn's Tips for Highly Effective Code Review - The New Stack

LinkedIn's Tips for Highly Effective Code Review - The New Stack: "In summary, having a formal code review process helps improve code quality, team learning, and knowledge sharing. The quality of work increases when every engineer on the team realizes two important things: someone else will read my code, so it better be good, and I’ll have to address any review comments I receive, so I should try to make my code good the first time around to save myself effort later on. When code reviews become an everyday habit, the team practices giving and receiving feedback on a daily basis. This is key for growth and improvement."



'via Blog this'

GitHub - twitter/reasonable-scala: An experimental Scala compiler focused on compilation speed

GitHub - twitter/reasonable-scala: An experimental Scala compiler focused on compilation speed: "Reasonable Scala compiler (rsc) is an experimental Scala compiler focused on compilation speed. This project is developed by Eugene Burmako and his team at Twitter.



 At Twitter, we have one of the biggest Scala codebases on the planet, and compilation time is consistently among the top asks from our engineers. With rsc, we seek to foster innovation in compilation performance, openly prototyping performance-focused designs and making our findings available to the Scala community at large."



'via Blog this'

Security: Exploits of a mom

Managing Data in Microservices

Managing Data in Microservices:



Randy Shoup shares proven patterns that have been successful at Google, eBay, and Stitch Fix. Shoup covers managing data, the need to isolate a microservice's data store behind the service interface, using events as a first-class tool in the architectural toolbox, techniques for service extraction from a monolithic database and much more.



'via Blog this'