BJanecke

You might be "fine" without it in a certain category of job, but rather than be dismissive about it you could be excited about having a massive wealth of information that you can use to do your job better.

There will always be something else to learn, wether it be how to apply Domain Driven Design to your work or how to work with graphs when munging data. It's always worth it.

[edit] Run on sentence

Understanding that nothing is purely logical nor is it purely expressionistic; by pigeonholing your perception of any design whether it be Code, Math or Art to either Logic xor Expression you are blinding yourself

The other angle for GEB is design

I read GEB along with Design of Design years ago following my mentor at the times suggestion, I would highly recommend doing this. Think of it as the Gödel, Escher, Bach, Brooks (Although Brook's writing style can be laborious at times) Recognizing patterns in all design work helped my understand my own design process better.

* Fred Brooks - Design Of Design

* Fred Brooks - The Mythical Man month

* Eric J. Evans - Domain Driven Design

* Design Patterns: Elements of Reusable Object-Oriented Software

* Kent Beck - Extreme Programming Explained

* Kent Beck - Planning Extreme Programming

* Michael C. Feathers - Working Effectively with Legacy Code

* Daniel Kahneman - Thinking, Fast and Slow

[EDIT] Correct the author for legacy code

* Upfront Salaries * Talent treated with dignity * Companies/Talent held accountable for showing up to interviews

// Find the first foo with bar foos.map(f => f.bar).uniq().orderBy(f => f.baz)[0]

does the same basic thing, the ability to collapse and display intent is incredibly rad for lack of a better word

The Mythical Man Month && Design Of Design by Fred Brooks

Everything else

Hitchhikers Guide (Existentialism does not have to be edgy) The Foundation Series (Bureaucracy and Institutionalization will never undermine Ingenuity) Dune Series (Plans within plans)

Go read https://www.digitalocean.com/business and https://status.digitalocean.com/ if that doesn't put you at ease send them an email.

However it shouldn't matter. Droplets are essentially just on demand "vps's" most of the operations work is done by your operations team(in this case I imagine this is you). Where your hosts(machines, containers, vps's whatever you want to call them) are shouldn't matter very much, what is important is that you have repeatable infrastructure, so that when you spin up a new VPS anywhere(AWS, DO, Vulcan, Your Garage) you can get up and running again fairly quickly.

[edit] Added status page

* Runs everywhere js/asm

* MIxed bag of tooling, but generally you can find something amazing and you won't have to venture to sourceforge or similar to submit a patch

* Doesn't suffer from the coljure/scala "We can totally use other JVM libraries but we only really do that If we have no other option"

* Absolutely beautiful generics and spot on inference

   ```
    function pluck<T>(key: keyof T, from: T[]) {
       return from.map(item => item[key]);
     }
   ```

* Incredible flexibility

   * sketch in js then annotate  

   * decide on strict nulls

   * decide on implicit types

   * various approaches to composition 

* One of the few cross-platfrom languages that feel pretty much identical on all the platforms

[edit] Formatting

It's not YAGNI or duplication, if you can't understand why we program to an interface and not an implementation then you just very seriously need to go look at your codebase and decide to extend a core bit of functionality, one that usually comes to mind is Authentication/Entitlement

So

``` Int => add(x, y) => x + y; ```

Doesn't get a test, however

``` Int => formulateIt(x, y) => (x * y)^y ```

Does