What does this even mean? There are all sorts of things that aren't driven by a platform vendor. Why do I care who creates something as long as it exists and works?

You're not following that line of arguments properly. It goes like:

cb: F#/VS integration works very well, out of the box, good support, documentation, tools, etc. Compared to Clojure, whatever, which doesn't work quite as nicely, because of lack of vertical integration.

ct: But that's because it's from the same vendor. Of course, things from the same vendor work well together. That shouldn't count.

cb: Of course it counts, and it should be given credit.

You don't care who creates what, as long as it works well, that's my point. I don't care why Clojure on Linux or MacOS is so hard to set up and why tooling, documentation, libraries etc, are hard to put together. That a well-designed language like F# is available on Windows with first-class support and native access to the .NET libraries with full documentation, is obviously going to attract the type of developers who prefer to use well-designed languages as opposed to ones like PHP.


This is like saying that my customized version of Android is more elegant than iOS. Or that PHP is the most elegant web development environment, now that I've written this terrific library that allows it to get around most of its complexity.

The process of getting VIM to work correctly with all the plugins, debuggers, compilers for different languages, build systems, etc, is not at all elegant. Having to edit configuration files to add code completion support for your language or change other settings is not elegant. Having to memorize a long list of commands just to do anything is not elegant. There being multiple plugins that do the same thing and having no idea which one should be used is not elegant. Having to understand, by and large, how VIM interacts with plugins and external programs, to do much of anything, is not elegant.

And VIM works just fine in Windows anyways.

The collection of tools as a whole, well they work just fine, but it's not elegant. It may even be preferable, but elegant is just not the word to describe how these tools operate in the real world. Unless you mean elegant in the sense that PHP is an elegant language. Warts and all, works well in practice.

I'm not sure elegant means what you think it means.

I'll be honest I have no idea what your point is or why you're focusing on such a narrow issue when I thought you were trying to refute this:

It seems to me the majority of development is non windows specific development tasks. So I'm not sure why you're so focused on them.

Two can play this game - I'm sure it doesn't mean what you think it means. You're also likely confusing the part with the whole. Exporting essential complexity to other parts of the system doesn't make the system as a whole more elegant. VIM having a lot fewer features, which are then added in the form of plugins and external programs doesn't make the development process as a whole more elegant. VIM replacing visual cues with user-memorized list of commands doesn't make the tool more elegant.

Oh yeah and Emacs > VIM.

You seem to think elegant involves the standard no-setup development environment. I think elegant means how simple and effective your development environment is - which usually involves setting it up the way you like it.

I'm not the best person to answer this, but I'll do my best:

When you install a program via Leiningen, there is a folder called "test," so hopefully that helps put that concern to rest a little bit.

I watched the first video of that SAAS lecture a while back. I recall him saying that it would take 20 years to do a full coverage test, and I guess I have to ask if you think this is a good thing. What point do you stop testing? Surely, you can't get to Sigma 6. To be honest, I don't agree with this assertion. The reason why is because this "full coverage" assumes you covered all the possibilities, and this can't be possible assuming you are dealing with an infinite system, right?

The reason TDD would fail is because you are trying to test over mutating values over an infinite time. If you are creating functions and classes that have internal mutation and return x values depending on y time, then what will happen at the 638th call? And does this ensure that the 699th call produces the values you want? This allows bugs to seep through because their is no way to logic about this.

If you take it in context that he is slamming into OO design, unexpected mutability, expected mutability, and the complexity inherent in managing this kind of complexity with a team, with the full knowledge that you can't possibly write full coverage, then his stance makes more sense.

What he is doing is promoting the ideas of functional programming, which generally discourages mutability, and most importantly, guarantees that a function will always return the same values and behavior. When your functions always behave the same, then understanding the logic of the program is much easier.

I don't think he is discouraging TDD per se, but I'm not too familiar with TDD outside of writing assertion statements, which I imagine is nearly equivalent to using print and display statements all over the place, so I'll leave it up to you to ponder if using functional programming concepts would reduce the need and risk, or outright eliminate, the need for TDD.

Both are important. But you're partially crediting open source tools for the work you're doing yourself. And no matter how much you configure, you have to deal with a ton of inconsistencies in how plugins and external tools work, not to mention version compatibilities, etc, especially when things stop getting maintained. Furthermore, relying on an esoteric, personal setup is not that elegant in a group setting.

Visual Studio is also highly configurable and extensible.

Edit: another way of seeing this is that the configuration process is part of the user experience. It cannot be treated as a separate thing.

Are we talking about using Windows-specific tools to develop or developing Windows-specifc application? Clowntable is handwaving away the superiority of Windows-specific tools by implying that they are only for developing Windows-specific applcations. This is not the case at all. F#/VS can be used to create web applications/services. And .NET documentation is fully supportive in this endeavor.

Lol. Just, seriously, lol.

Edit: Let me make another claim that you'll probably hate. Developers that use a standard development environment without any customizations are probably worse developers on average than those that know/choose to customize their environment.

Interesting. I was under the impression that Noir is very non-opinionated, especially compared to RoR. If I understand it correctly, RoR enforces MVC, TDD, and NoSQL. This seems highly opinionated to me. Noir doesn't even come with a Controller folder, and has no interop with a database.

The way you would interact with Noir is completely up to you, and it would be pretty difficult to enforce any code organization in Clojure.

To clarify a bit, Ring is only a web servlet, and mostly abstracted away underneath other frameworks. Alternative frameworks include Compojure and Mustache. In fact, Noir is actually an abstraction over Compojure and Ring.

If you really code at the metal, you can just install Leiningen + some HTML handler.

Brendan Eich was originally going to make javascript a form of Scheme, but I guess minds were changed. The common story is that he was hired by a bunch of pointy-hairs who didn't know what Lisp was and then they guffawed when they saw it. This isn't the truth as far as I recall.

If you work in a Linux shop with a bunch of other developers long enough, eventually you have to learn both VI and Emacs and a bunch of other random esoteric tools different people use because, tools you use aren't set up on their machines, tools they use aren't set up on yours and often there's nothing quite like two developers working together on a single machine to resolve issues. I mean everyone had a different meta-key sequence for screen (multiplexer) and I had to memorize them all.

Huh? I would agree with this claim. And I agree that PHP developers are probably being slightly worse than, say, Ruby (or some other sane language) developers. I may even agree with Windows developers being slightly worse than other developers, especially in situations where Windows is the default choice. But this is mostly just the Python paradox (http://paulgraham.com/pypar.html) and has little to do with the quality of PHP or Windows.

Unlambda is a terrible programming language but people who know it well are probably well-above average programmers. 20-year olds who know C very well are probably very good programmers compared to their peers, 45-year olds, not so much.

It's definitely less opinionated than rails. It's similar to what sinatra is for ruby but for clojure. Google it if you want. You don't need ruby experience to compare it to noir. I haven't touched a line of ruby in my life.

Noir has a router which is basically a controller at heart. Your router handles the association between a url pattern and some form of action (send json over the wire or render a template, etc.). I don't mind this at all.

I don't like how it assumes I want to use its validation by including it. I also don't like the idea of session flashing messages as part of the core. It also has template partials baked into the library. That's a mistake too because that functionality should live in the template language itself.

Express is similar but it feels like Express is like 2 years in the future compared to where Noir is at. Also the project on Github seems dead unless it's being hosted somewhere else now? It hasn't been touched in months.

I wouldn't avoid it if you want to do web apps with clojure though. The core concepts of what it's trying to do is pretty nice. I like the concept of middleware a lot for web development.

Lol, again. I've only ever worked in "choose your own environment" shops and I've never had these kinds of issues. I don't need to know every keyboard shortcut a person uses to work with them on a problem.

As for the rest, I really don't know what your point is. It might just be that I'm missing something - but nonetheless I give up.

Edit: Not to mention the idea of forcing everyone to use the same tool just to make working on each other's machines easy is basically absurd.

do people ever really have to use other peoples machines?

who works in these shops?

You're reading far too much into any of this. I don't have a problem with any of this, it's just not elegant. It may even be preferable, but it's not elegant. I don't have a problem with memorizing everyone's keyboard shortcut keys so that if I come over to help out with something, I can take over instead of simply dictating. But it's not an elegant solution. I don't know why you keep interjecting with nonsense that has nothing to do with the topic at hand.

Would iOS become more elegant if people were allowed to configure standard gestures to mean completely different things? If different versions came with different defaults? Would it be elegant if an iPad application completely ignored the UI conventions and remapped all the standard gestures to mean completely different things, while adding plenty of unintuitive, non-standard gestures? What about a different iPad with similar functionality had a completely different set of gestures for the same functionality? Is it elegant that Emacs and VIM have their own keyboard shortcuts that are not at all consistent with other applications in the same platform?

It's perfectly reasonable to prefer inconsistency, heterogeneity and plain weirdness even, but one should apply the same leniency to PHP. PHP's faults as a language are quite easy to work around.

I assumed he meant cases where you're helping someone solve a problem (or they're helping you) and you're both at the same computer. Definitely not the typical scenario and certainly not the right one to optimize for.

Candybar, got it. You think the elegance of a solution is based off on a tool's initial state and how easy it is to share it with other people. I think its based off of how well it works for me when I'm programming.

We have now established that Linux/GNU/OpenSourceTools/etc is less elegant than VS in accomplishing the former, we haven't established at all how it's more elegant in accomplishing the latter. Of course, they all matter.

We've established that, eh. Nice.

We've also established that you owe me $500,000.

I have now cited several specific, indisputable cases where using super-customized VIM/plugins/external-tools/etc becomes inelegant (initial configuration, sharing a session, etc).

You have not cited a single specific case where using VS becomes inelegant, other than implying that you had some unspecified bad experience with VS.

Edit: You're mostly just relying on snarky remarks, appeals to obviousness and dishonest, dismissive summaries of the opposing arguments, instead of putting forward any reasonable case. Why are you even bothering?

It's a good question - because I honestly have no idea what your point is. I feel like we just keep going into random tangents that are narrowly defined by you (major platform vendors platform specific code, setup of development windows, sharing computers amongst other users, etc. etc.).

So, uh, you win?

how are you comparing VIM/Linux/OSS to Visual Studio? the first are meant to be broadly used for many different purposes and languages, while VS is meant to be used for a tiny few. the goals of each are different

a fair comparison would be to take VIM/linux with all of its very customized plugins and then compare efficiency to VS without all the 'elegance' talk that then becomes irrelevant, since both tools will then be highly customized for their specific purposes

Hey Greg,

Efficiency is even harder to compare than elegance. I'm sure a lot of people were more efficient on Wang than they are on iPads. Most PHP developers are probably more efficient in PHP than in any other language. This doesn't mean much.

I'm saying that the developer experience is inconsistent and often unnecessarily made difficult due to a plethora of tools with no defaults, no centralized design and little coordination. And that this is what people mean by inelegant. You can achieve some central coordination by assembling a set of tools, editing configuration files for all those tools to set reasonable defaults, etc to get to a reasonable state. But it's still not as simple or consistent and takes a lot of work. That I can get around lack of centralized design in PHP doesn't mean PHP is elegant.

There's some confusion here - arguably, Linux's design is elegant and the Unix way is elegant. Even VI can be said to be elegant as a single entity. But the totality of the product actually offered to me as a developer: Linux + VI + Emacs + a whole bunch of plugins/scripts/libraries/extensions + a whole bunch of external tools, that I need to choose from and basically assemble myself is not elegant. It will become more elegant once I'm done with curating. But then I have to maintain that curated product. And the process of doing that is not at all elegant. And the result works decently well, but it's not that elegant. Not compared to VS anyway.