Making Dense Codes Even Denser: Fill & Download for Free

We do not use “RISC” or “CISC” architectures.We use architectures that have been designed with either RISC or CISC design philosophy.CISCThe main point of CISC design philolosophy is minimizing code size; in 1970s memory was very expensive so dense instruction encoding (with variable-length instructions, and complex instructions which did lots of things with single instruction) were needed to minimize memory needed for storing the program code.Dense code is again important, for different reason: Even though memory is now very cheap (compared to program code sizes), the latency of memory is now so long, that accessing that DRAM memory we may take hundreds of clock cycles. So we have caches, very fast (and quite small) memories on the core or near the core. These try to contain the data and instructions we need the most. The denser our code is, the more instructions we can fit in a small cache, and the less often we need to go to the slow DRAM main memory or slower outer level cache.RISCThe main point of RISC design philosophy was to make pipelining easy. When each instruction only performs a very simple single task, those instructions can be very easily pipelined. And with pipelining the total number of instructions executed per second can be much greater than without pipelining, so for performance, it does not matter that each instruction performs slightly less work.One of the main things about this simplicity was make instructions as easy to decode as possible. Another one was to eliminate instructions which have to be implemented using microcode interpretation.Also, when the instructions are simple, the core can by made smaller, simpler and more power-efficient, and (more) area can be used for caches.But eventually the computer architects of mostly Intel (but also other companies like Motorola(*), AMD, NexGen and Cyrix) learned efficient tricks to pipelining also CISC instructions, soon eliminating this main motivation and performance advantage of RISC. However, the more complex instruction decoding of CISC-style architectures does cost some power, making RISC-style architectures typically more power-efficient.ARM, which is the instruction set architecture used in phones and tablet, is “officially” called RISC, but it is quite far from being a “pure” RISC, it retains lots of quite expressive instructions and addressing modes, it tries to take combine the best parts of RISC and CISC.(*) (However, Motorola still decided that RISC is the way to go and did not really try to aggressively sell their advanced derivates of 68k(CISC) series like 68060 and stopped the 68k development after 68060 and concentrated on PowerPC(RISC) instead)

The type system should be at the core of a language's design.The type system of a well-designed language is not there just to catch trivial bugs and incompatibilities: it should help direct the design and organization of programs and, more generally, aid the programmer as much as possible. This requires a level of simplicity and consistency throughout the entire language that simply cannot be achieved by bolting types on after the fact.The design of a language and its type system parallels the design of a program. In some languages, you write your program first and then try to get it to fit the type system—the type system is a hassle you put up with in the hope of preventing errors. In other languages, you lay the types out first and use them as the fundament for your whole program—the type system guides you to your destination. Somebody, Conor McBride I think, had a great analogy for this: types are sources of gravity which we place in the space of programs and the rest of our code naturally falls towards them.The second approach, I believe, is entirely superior. Not only is it more powerful and more expressive but, once you get the hang of it, it's actually easier. I've written code in Haskell that would have been too tricky normally, because the types guided me every step of the way. And when I come back to it later, it was easier to understand for the same reason: I could simply follow the types. It's like a puzzle where each piece has distinct connectors—much easier than one where all the pieces are identical squares. Sometimes you don't even need to see the whole picture because you can put everything together based on which pieces fit.A language should be designed in the same way: start with types and build up constructs that work naturally with them. This flavor of design is illustrated well by algebraic data types (ADTs) and pattern matching. We start with types (ADTs) and add language features to support them (pattern matching) which, in turn, helps build out the structure of most programs. The process is entirely symbiotic. Once you have an algebraic data type the natural course is to pattern match on it and your program follows the shape of the types.A simple example: an arithmetic interpreter. We start, of course, with the type: what sort of expressions do we support?data Expr = Lit Int  | Add Expr Expr  | Sub Expr Expr  | Mul Expr Expr We can add, subtract or multiply and we can include literals. This is the basis on which everything else stands. How do we write an evaluator for it? Well, we start by matching on each possible case—something your editor can do automatically!—and the rest of the code flows naturally:eval :: Expr -> Int eval (Lit n) = n eval (Add e₁ e₂) = eval e₁ + eval e₂ eval (Sub e₁ e₂) = eval e₁ - eval e₂ eval (Mul e₁ e₂) = eval e₁ * eval e₂ This is a pure example of following the types. In a sense, our code is a layer laid down over the skeleton provided by Expr. And sure, realistic examples will be more complicated, less pure—we'd need error handling and logging and metadata and what have you—but the underlying idea is the same. The core of the program is simple and elegant and it will shine through the crud imposed by real world software engineering.The same should be true in language design. I'm a firm believer that every language should have a simple, elegant core—and the type system should play a prominent role. This is where the λ-calculus shines: it's about as simple as a language can be without being completely unintuitive. Languages should be designed around a small formal kernel even if you don't care about proofs. This kernel, probably some λ-calculus variant, forces your design to be simple and consistent to an extent I've never seen otherwise. Languages designed in an ad-hoc manner, without a simple underlying formalism, tend to sprawl, to grow special cases and perverse inconsistencies. Language design is hard. Starting small and simple helps you—it's not just academic frippery.And sure, again, the real world will throw you some inevitable complexity. You'll have special cases for certain types and system calls and operations and sometimes your abstraction will leak at its edges. But at least you have an abstraction, one guaranteed to be simple and consistent, and it will shine through to the users of your language. At the very least, you will be able to know exactly how it leaks and where behavior diverges from the ideal. Without it, you wouldn't even have an ideal! How can you say what wrong is if you don't define right first?The type system is a core part of the programming experience so it absolutely has to be a part of the language's core. Simplicity is a boon both to your programmers and yourself: the language will be easier to learn and easier to design.Haskell is a perfect case study. Haskell's type system, despite its reputation, is surprisingly simple. Incredibly expressive, of course, and perhaps tricky to learn, but it boils down to a mere handful of rules. With a bit of fancy notation you could express all of it on a single piece of paper—and the notation isn't even all that fancy except for exotic letters carried over from mathematical tradition. The actual rules are just patterns to match: you see an expression that looks like X and you give it type Y. If you were so inclined you could convert it to a short Prolog program with a few changes. It's dense, much denser than prose, and hard to follow unless you're used to its conventions, but even with those caveats it's impressive: the entire type system, how to typecheck programs and, implicitly, a type inference algorithm, all boiled down to a single page of Greek letters. (Figure 2 from "System F with Type Equality Coercions" is a good example.)Typing judgements like that are the math equivalent of code, and as code goes they're pretty short. And in code, short is good.This small core helps Haskell, with its sprawling features and extensions, stay consistent. It's been incredibly robust: for all that Haskell has grown, for all the features added to it over the decades, the core only gained new rules a couple of times. There are a few other details—built in type like Int or arrays, unboxed types and so on, but they're all easy to rectify with this core.That, in my mind, is exactly what well-designed languages should aspire to.I've seen the complete opposite approach too. TypeScript has a type system designed in an entirely post-hoc way out of completely understandable practical considerations: large projects are already heavily committed to JavaScript and TypeScript offers them at least something. "I can't believe it's not JavaScript."But looking at the language abstractly, ignoring sunk costs and external engineering concerns, the language is a mess! The types are a pain, it's easy for mistakes to sneak in anyhow, it's hard to type existing JavaScript idioms, it's hard to add types to your existing programs. It's verbose, it's inexpressive, it simply can't have good type inference. The design of the type system is driven entirely by the design of JavaScript and so it's more complex than it has to be. (Perhaps this is complexity inherent to JavaScript, normally hidden by being relegated to runtime.)This doesn't mean that TypeScript is a bad project—it's dictated by its goals and its environment. It knows what role it wants to serve and serves it reasonably well. Engineering, people say, is all about tradeoffs. But it's a great example of what you should not do in designing your types unless you have to. Tradeoffs go in both directions and unless you have the same constraints as Typescript, you shouldn't make the same compromises.The real world, it turns out, sucks.But part of the fun in designing a new language is that we can create our own world. Starting with a simple core and building around a type system we can make our world suck less. That's the real magic of abstraction, after all, and you get to be a real wizard.

Silicon Valley is located directly atop the San Andreas Fault. The area historically experienced a major earthquake every 110 to 140 years, and the last big one was 158 years ago, so it is overdue for a big quake. You don’t want to be in a high-rise building in a major quake - even low-rise buildings are going to fall down if they are improperly constructed. Building codes reflect this.California has always sprawled horizontally, whereas New York has always built vertically. It’s a regional style of development which arose when California had far fewer people than it has now, whereas New York was densely populated from the start. However, with its huge increase in population in recent decades, California is now approaching European population densities, and the horizontal sprawl and vast freeway systems of the past are a waste of valuable land and run up building costs considerably. Californians need to reconsider their lifestyle in terms of land conservation and using public transit rather than freeways. They need to build more like Europeans to make their towns and cities work with their denser population. This would be a huge change in lifestyle for them.