Moserware

The best blogs don't have daily content. In fact, the best blogs usually post once a month, or less - often much less. Here are some: http://prog21.dadgum.com http://www.moserware.com http://ridiculousfish.com/blog http://wingolog.org/

I recommend this blog post as a good primer for TLS. http://www.moserware.com/2009/06/first-few-milliseconds-of-https.html

I did not see it in the comments, so here is a great article on how the handshake happens : http://www.moserware.com/2009/06/first-few-milliseconds-of-https.html

I wouldn't say Haskell is the perfect language for protocol specs. I do love Haskell, but what you're asking for sounds more like this: http://www.moserware.com/2008/04/towards-moores-law-software-part-3-of…

This is another awesome article on the topic: http://www.moserware.com/2009/06/first-few-milliseconds-of-https.html More on the "technical" side (and it's a bit old), but it's still totally worth a read.

Ahh, Turkey strikes again! The Turkish locale is notoriously difficult to handle for a variety of reasons. One of my colleagues wrote an excellent post about the different ways that Turkish conventions can break your code: http://www.moserware.com/2008/02/does-your-code-pass-turkey-test.html This seems to be yet another one!

From reading about DF, and especially the NYT profile of DF and the creators, I get the strong impression that DF is very much being done the hard way, even ignoring the C++ aspects, and one could cut down the complexity tremendously with good abstractions and things like DSLs. (Think the Viewpoints OS strategy - with good enough abstractions and DSLs, you can do an OS or languages in very small sourcebases; I'm still in awe of their TCP/IP strategy - parsing the RFC illustrations! http://www.moserware.com/2008/04/towards-moores-law-software-part-3-of… ) That would be a project worth doing.

Jeff Moser's blog is full of good articles, I revisit it from time to time hoping he's posted something new, but I think he's been too busy these passed few years. One of the most accessible and interesting is his HTTPS breakdown[1]—highly recommended, and I'm sure it's been HN'd more than once. [1]: http://www.moserware.com/2009/06/first-few-milliseconds-of-https.html

Author: I read (well.. began reading) your previous post on the TrueSkill algo (http://www.moserware.com/2010/03/computing-your-skill.html). Great job!!

I'll link to your TrueSkill post for those who haven't read it (it's excellent): http://www.moserware.com/2010/03/computing-your-skill.html Although I already knew and understood TrueSkill before your post, it helped solidify my understanding. I hope you write more articles like that in the future :)

I think this roughly reflects my philosophy in languages as well. You basically have two options: you can bend your problem to your language or your language to your problem. The former is epitomized by Java and Python--all Java and Python code looks the same, regardless of what it's actually doing. The latter is the domain of Lisp and Haskell and Forth and so on. I'm unabashedly in favor of the latter. Ultimately, it's easier to reason about some domain in that domain. I would love my code for any particular project to look very similar to what I would write on a whiteboard when solving the problem. If I'm solving something inherently mathematical, I want the code to resemble math notation. If I'm writing some parsing code, I want it to resemble a grammar. If I'm writing an interpreter, I want it to resemble the operational semantics of the language. This fits into more "practical" domains as well: if I'm writing a web app, I want the routing to look like, well, routing and the database code to look as close to the database structure as possible. Any details in the implementation rather than the domain should be separated from the domain logic. If you're trying to make the domain logic mirror the domain itself, this is essentially inevitable. This makes your code more general and easier to debug. You can redirect your domain logic to a different backend, and it's much easier to figure out whether you have a problem in the implementation or the logic. More generally,…

It was a risk though, because I had to trust that I understood the problem domain well enough to invest a lot of time in the parser/interpreter. - First comment on blog http://www.moserware.com/2008/04/towards-moores-law-software-part-3-of… Solving a problem is hard. Generalizing it to a class of problems is harder. Encapsulating it in a language with specialized syntax and semantics is harder still. I think this is one reason that DSLs are not that popular, and is one reason why most new languages mimic existing languages like crazy (apart from for user-familiarity to ease adoption). The exceptions, like brainfuck and lolcats, use familiar semantics; and are only novel in syntax. As for a Moore's Law for software, I'm going with Fred Brooks' Law of "No Silver Bullet". Complexity is hard, the best we can do is abstract away foundational concepts into components, as we understand them, and then SOTSOG. The TCP/IP diagram syntax is really cool - but because it's clear, not because it's short; I think the parsing code in C would actually be shorter than the ASCII art.

> In C# I can simply do this: "hello world".ToUpper(); Hmm still actual: https://www.moserware.com/2008/02/does-your-code-pass-turkey-test.html

This is what I know; wish I knew more. AES won due to software performance. https://www.moserware.com/2009/09/stick-figure-guide-to-advanced.html

Some good ones: http://avc.com/ http://paulgraham.com/ http://www.moserware.com/ https://believermag.com/ https://blogmaverick.com/ https://fs.blog/ https://juliagalef.com/ https://marginalrevolution.com/ https://nav.al/ https://sive.rs/ https://torrentfreak.com/author/ernesto/ https://vitalik.ca/ https://waitbutwhy.com/ https://www.lrb.co.uk/ https://www.metafilter.com/ https://xkcd.com/

First, a good article about TrueSkill I found when looking for systems to rank pairs of foosball players: http://www.moserware.com/2010/03/computing-your-skill.html Second, apparently Tinder uses an ELO ranking system for their algorithm. I would add a link but everything I'm finding online right now is very clickbait-y.

http://www.moserware.com/2008/02/does-your-code-pass-turkey-test.html This is old but still valid reading...

ObTurkeyTest: http://www.moserware.com/2008/02/does-your-code-pass-turkey-test.html

Related: The first few milliseconds of an HTTPS connection (http://www.moserware.com/2009/06/first-few-milliseconds-of-https.html)

You can't do it from a browser, but the "tls client hello" could certainly hold a custom message of sorts. Either in the "random bytes" it's supposed to send, or stuffed in as a fake cipher preference in the supplied list. Good breakdown of the handshake here: http://www.moserware.com/2009/06/first-few-milliseconds-of-https.html (skip down to the client hello)

I'm reminded about the STEPS report of using ascii art from the rfcs as a DSL for describing tcp: Writeup/comment: http://www.moserware.com/2008/04/towards-moores-law-software-part-3-of… Comment thread: https://news.ycombinator.com/item?id=846028 The vpri texts: http://www.vpri.org/writings.php Appendix e and section "A Tiny TCP/IP Using Non-deterministic Parsing" of "STEPS Toward The Reinvention of Programming: First Year Progress Report, December 2007.": http://www.vpri.org/pdf/tr2007008_steps.pdf

You could do secret splitting: http://www.moserware.com/2011/11/life-death-and-splitting-secrets.html It's vulnerable in that whichever threshold N that you choose allows for N participants to conspire to publish ahead of time, or M - N to conspire not to publish after the fact.

Does implementing TCP/IP stack using the RFC (as in parsing diagrams straight from RFC) counts? Then it was done in OMeta [1]. Previous discussion: A full TCP/IP stack in under 200 LoC (and the power of DSLs) [2]. There's also a PNG parser (but it is not parsing any documentation) in 20 lines of OMeta [3]. [1] http://www.moserware.com/2008/04/towards-moores-law-software-part-3-of… [2] https://news.ycombinator.com/item?id=846028 [3] http://joshondesign.com/2013/03/18/ConciseComputing

You can eliminate the impedance mismatch entirely by using the specification as your code [1], as Alan Kay's Viewpoints research team did. ;) [1]: http://www.moserware.com/2008/04/towards-moores-law-software-part-3-of…

Ometa: http://www.tinlizzie.org/ometa/ (article on processing TCP with ometa using the RFC tables as a packet definition http://www.moserware.com/2008/04/towards-moores-law-software-part-3-of…

I created a C# implementation and explained how the math works in http://www.moserware.com/2011/11/life-death-and-splitting-secrets.html

I did it many times elsewhere in this thread already. For example, this one: http://www.moserware.com/2008/04/towards-moores-law-software-part-3-of… Or Nanopass itself, not just as a tool for building DSLs, but as an example of a nice and clean DSL (of course, if it could bootstrap itself it would have been even better): https://github.com/akeep/nanopass-framework Or everything you can find in my github repositories (username: combinatorylogic).

OMeta is an interesting place to start, there's implementations for a ton of languages. Here's a good description of the motivation for OMeta and the .Net implementation: http://www.moserware.com/2008/06/ometa-who-what-when-where-why.html

This is neat to see! Reminds me of the 200 line TCP/IP stack: http://www.moserware.com/2008/04/towards-moores-law-software-part-3-of… which has a previous HN discussion: https://news.ycombinator.com/item?id=846028

The two algorithms I have been getting a ton of mileage out of lately are Bayesian Bandits and variations of the TrueSkill ranking algorithm. Bayesian Bandits Explained: https://www.chrisstucchio.com/blog/2013/bayesian_bandit.html TrueSkill Explained: http://www.moserware.com/2010/03/computing-your-skill.html