3,702 karma · joined January 17, 2008
Posts and conference talks: adamsolove.com
While internally-homogenous states may have peaceful domestic politics, their international politics become more troublesome. First because the exact same ethnic hatreds translate perfectly well into wars between nation-states. And second because many cultural groups, when assembled into their own homogeneous state, simply don't have the economic or military resources to defend themselves against aggression from larger neighboring groups.
An excellent history of exactly this dynamic -- how domestic government organization and international strategy interrelate -- is the book "The Shield of Achilles".
To learn about the challenges of typing complex concurrent systems and some of the cool approaches for doing it, I highly recommend this talk by Zeeshan Lakhani: https://www.youtube.com/watch?v=-8jLRThHuFQ
We used to live in suburban Washington DC and I didn't let my kids out of sight of the house.
Now we live in suburban Denver. We cared about play a lot so we used it as the main criterion of where we bought a house. We drove through neighborhoods on Saturday mornings until we found one where kids were out riding bikes and playing without adult supervision. We found a neighborhood that was both well designed (pools, a network of walking trails away from roads, school in walking distance) and full of people who were culturally supportive of free-range kids.
If you want to find or help to foster such a neighborhood, I recommend the book we used, "Playborhoods": http://playborhood.com
His critique of architecture is this: the quality of a building comes from a process which has to unfold over time and take into account very minute preferences of the kinds of people who will actually inhabit it. A good house design can't be measured by the plans, but only by living in it and seeing what kind of life occurs to the people who are there. Therefore, if you build it by one person's design, or because the renderings look nice as a 2d composition or as a 3d model, or to reduce costs by repeating the exact same things over and over, you will necessarily end up with a bad building. It won't be bad on purpose, but the power structure of the process that built it will have made it bad. (Maybe an architect wanted to win an award, or a developer wanted to sell the properties quickly without worrying about the owners' long-term experience, etc.) And if you want a better building, instead of arguing about design, you should just find a process where more of the decision-making is made by the kind of people who will inhabit the house.
The same is true of software. I do not think most people set out to make bad software. But Conway's law tells us that the result will reflect the organization and process by which it was created. If the process of creating the software is embedded in a large corporate structure where VPs are fighting, that politics is necessarily felt by developers and even embedded into the system. If the process of creating the software is embedded into a VC unicorn and its only chance of growth is to destroy local communities or mistreat workers on a large scale, that will happen.
This is even true just for the people building the software. I've worked at companies where the design team had the power, where the engineering team had the power, or where the project management tool had the power. The same people might work with the same goals, but in these three environments they will produce three very difference pieces of software. And I've worked at companies that had the power to trick money out of customers, which soon replaced the desire to actually provide customers any benefit, and produced its own unique form of engineering environment.
Alexander's critique is aimed at the very idea of "scalability": any one person or process who can determine the way architecture (or software) behaves for thousands of people will get it wrong. Not because the person is bad or the decision is inherently wrong. But because no one decision could possibly be right for all of those people.
The bigger complaint about software patterns is that, unlike Alexander's original patterns, they are merely tools useful to build any kind of program. Alexander's patterns were meant to only be useful in building humane places with humane processes. You literally could not build a mass prison with the construction methods he describes, because they aren't amenable to mass production, design from afar, or economies of scale.
Exactly the opposite is true of our usual application of "software patterns". They are often used to produce software that is inherently immoral. Alexander's patterns describe an environment of decentralization of decision-making about both architecture and the community it inhabits. Meanwhile, our "software patterns" embed a centralized power structure both in the code (architect->team lead->junior programmer) and in the world now increasingly controlled by the whims of Silicon Valley founders.
I wonder what it would look like to describe low-level primitives of computation, similar to Alexander's new low-level architectural methods, which actually made decentralization of power a reality and resisted economies of scale. They certainly wouldn't look like the Gang of Four patterns.
Eve may not turn out to be the right abstraction away from details. But the parent comment complaining about the details it takes away from the programmer is probably on the wrong side of history.
If that's what this is, a new field outside "programming" that allows an order of magnitude more people to author behavior for simple systems, that'd be amazing.
It is not a new mistake. Many people thought that programming with GC, or with high-level languages, or with generics, was just a kind of magic that couldn't lead to understandable programs. But these things succeed because, while they allow you to stop worrying about certain details, they do so while still remaining perfectly well-defined and unambiguous.
The fact that you no longer can know how the low-level details will be handled can be very uncomfortable. If there is most of what you have spent your programming career doing, it seems like it must produce ambiguity and inefficiency. But this isn't generally the case. Optimizing OCaml compilers can often produce code faster than C simply because the higher level of expression expected from the programmer leaves more room for the implementation to generate the right low-level code.
I won't say that I know Eve will be successful, but it certainly is possible. It produces unambiguous behavior which just happens to no longer specify lots of details most programming environments make you think about. When I think about the work I do, most of which involves providing live representations of data, and executing certain rules when it changes, I would guess that most of the details I worry about are extraneous and could be dealt with by a sufficiently-smart environment that encompassed both the database and the program.
You don't hear about intrusions into self-hosted source repositories. Not because there are fewer, but because they likely don't have the security infrastructure in place to know that they ever happened.
Looking at the little maps in the article, I might hesitate a guess that this model has been over-fit to a certain idea of "civilization". It predicts Egypt and Rome and Greece, things people know about. But it doesn't seem to predict the Byzantines, Sogdian and other Central Asian empires, peaks and troughs of Chinese dynasties, etc., which were just as long-lived and influential but are less well-known.
I wonder what would happen if they modeled resource availability, language overlap over time, political ideology (large empires tend to become inward-looking), etc. War is certainly an important factor, but not the only one.
The argument isn't that a life sentence can be fully reversed, just that it can be modified later, which death cannot be.
You probably know us from... the sticker on your laptop? your favorite open source logo? every conference schwag bag ever?
Customers love that StickerMule makes it easy to print out high-quality custom stickers.
What they may not know is that we have an awesome, all-remote culture, with folks spread across the world. We're a small team (11 engineers) at a profitable, non-VC-funded company. There's little bureaucracy, engineers get to take ownership for all aspects of their projects, and there's room for good ideas to come from anywhere.
We're currently working on some very fun technical projects to build a new platform for our site. There are a lot of interesting problems: splitting a problematic current codebase into small Ruby services, writing JavaScript domain models with Flow type-checking, and traditional web UI product work.
Best of all, it's a low-stress, blame-free team, with just three standups a week in synchronous meetings. Other than that, I get to set my own hours, walk my kids to school, take a long lunch break with my wife, and do good work from anywhere.
Questions? Hit me up at adam@stickermule.com
For formal details and application, see: https://www.stickermule.com/jobs?job=714da6cc-dc8b-4453-8bd6...
Now, I work from home, so I usually work something like 8am-3 plus 8pm-9 so I can play with my kids after school. Highly recommended.
But if you're asking this question, then what you probably need is advice about how to talk about this with your boss.
For example, if you go to your eye doctor, they can bill you for a standard visit, a refraction (getting your prescription), an eye health check, a super-duper health check because they found something and needed to look at it more, an eye health check with dilation, etc.
I have gone to eye doctors who will do everything and then ask at the end of the appointment what my insurance situation was. If I'm on insurance, bang, they charge me for all of it. If not, they just charge me for the refraction and forget about the rest.
The value of data is determined by the intelligence of those interpreting it, not those who recorded it.
Of course, this dynamic is sometimes positive. The Babylonians kept excellent astronomical records though apparently making little theoretical advance in understanding them. Greeks with an excellent grasp of geometry put that data to much better use very quickly. But if they had had to wait to gather the data themselves, one can imagine them waiting a long time.
But I do think it's worth spending a week living your normal life but without a smartphone to see how you personally are different. Don't just go on vacation and "disconnect". Try living your life but disconnected. It's interesting. You have to get places earlier. You have to make plans that have pre-arranged fallback plans. You have to have something to think about to not get bored. (Or, at least, I do.)
I only recently read David Reed's thesis and did not know about this later work until you mentioned it. Almost all of the links I can find about Croquet no longer work. (OpenCroquet and OpenCobalt websites seem to have disappeared.) Can you recommend reading for someone who wanted to understand the design decisions made in the several versions of Croquet?
I have been experimenting with layering pseudo-time on top of asynchronous message-passing in Erlang. One useful trick which I have not yet seen published is that you can have two-dimensional pseudo-times, so that one running system can track multiple chains of causation. (You would not want this happening all the time, since the whole point is to get a consistent history everywhere. But it is very useful for developers.)
An example: Let's say I have an existing object and a clone of it where I have changed some of the methods' behavior, but I want to understand all the consequences of these differences across all the distributed objects they cooperate with. I can send them the same message with different y-coordinate pseudo-times. In a system that relied on wall clock time, the side-effects of these two message sends would merely step on each other non-deterministically. But with pseudo-time, their effects are causally distinct throughout the system and can be dynamically inspected, making it a lot easier to build a human understanding of the behavior of the distributed system.
Most people building commercial distributed systems today accept a different set of tradeoffs, generally preferring fast performance and the avoidance of possible deadlocks even though it means giving up some of the nice semantics and consistency of the operations.
Do you still think it is possible to build a system with the organically-growable scale of the internet but with some of the nice, predictable pseudotime-like semantics?
If you join a startup that gets acquired but before your shares vest (or with preferences that kill the value of your shares), it's true that you still got paid well above an average non-programmer salary. But it's also true that you could have spent those years working for a much bigger salary at a big company. Or worked 35 hours a week and had a lot more fun with a significant other or friends. Or started your own company that might have turned into something you totally owned.
There are certainly startups where the net dollar value that the engineering team turned down by not working at Google is as much risk as all the investors put in as cash.