8 ms·
In the stated examples there's are no benefits to the additional complexity. No one would argue that complexity for the sake of it is a good idea. That'd be ins
by onion2k 13y ago
In the stated examples there's are no benefits to the additional complexity. No one would argue that complexity for the sake of it is a good idea. That'd be insane. If Alice's restaurant could handle 5,000,000 covers a night with only 1 member of staff while Zola's restaurant could only handle 10,000 then you'd have a more realistic scenario to compare with the SaaS industry. The benefit of "complexity" is that you are able to do more things with less work.
The ideal is to build powerful systems from small, simple processes - if any single stage is trivial then anyone can understand it, fix it, modify it, and so on. With many little processes working together you can do amazing things. A good example in software is a build process - a good system can lint code, test it, uglify it, minify it, push it to version control, watch for changes, reload an output mechanism, clean up a distribution, and push it to a live server if it's working all from a single command. That's very 'complex', but really it's just a set of very simple linked processes.
- workhere-io 13y agoNo one would argue that complexity for the sake of it is a good idea. Yet somehow we've convinced ourselves that frontend development now requires package managers, compilers, CSS test cases, CSS frameworks, etc. Sure there are web-based apps with a rich functionality that require some of these things, but the vast majority of pages that I see out there are just as simple as they were five years ago.
- idlewan 13y agoIn the case of some front-end tools, they are an absolute must. When your CSS compiler takes care of all the stupid -webkit-/-moz-/... prefixes, allow you to define variables, mixins, use loops, you gain a great amount of power and your code is a lot cleaner. When your build system integrates with livereload and make your changes appear instantly as you save, you gain speed and comfort. That's major benefits for little to no inconvenience. I don't know about the necessity of CSS frameworks, styleguides or package managers, but some tools are just too good. It's not about the end result, it's about using better tools to get to it.
- Joeri 13y agoYou don't need a build system during development. I work on a 500.000 line web app, and it has no dev time build step. You check out the source into your web root, and run the app. Edit + f5 is fast enough, no need for smart build systems. Build steps are ofcourse inevitable for the jump into production.
- idlewan 13y agoFor my front-end dev, it's really: (modify Stylus line, save).repeat(500) vs : (modify Stylus line, save, focus terminal, run make (or whatever your build tool is), focus browser window, ctrl-r, focus editor window).repeat(500) Of course, if you're not taking advantage of better tools than pure CSS, it's still: (modify CSS line, save, focus browser window, ctrl-r, focus editor window).repeat(550) You don't NEED livereload, it's just a lot more comfortable.
- Joeri 13y agoWell, maybe my perspective is different because i don't touch css that often, seeing as i use extjs.
- mcguire 13y agoHow old is your CSS compiler? After gaining a fair amount of experience with various technologies over the years (by which I mean, getting burned (especially by things that seem wonderful and then cease to exist for a variety of reasons)), that has become the single most important question I ask about a new technology. If it's been around for ten years, it'll probably still be around in ten years. If it hasn't then it may not, especially in a form recognizable as related to today's. C and Java are, well, not horrible, but bad. However, C has been C for my entire career. And I'm fairly sure that if I write something in simple, plain Java, in five or ten years when it needs some significant work then that work won't start with a complete rewrite.
- idlewan 13y ago
- vog 13y ago> The ideal is to build powerful systems from small, simple processes That's only half of the story, because now the complexity lies in orchestrating those processes. Let's stay at the example of build systems. These are usually a serial execution of simple processes, so they make up a "best case" scenario. Yet, build systems quickly reach a uncomfortable complexity. See Autotools, CMake, and so on. It is kind of ongoing research: Every few years we find better ways to orchestrate a build system. As of today, there is no build system which is 1) simple and easily comprehensible, 2) reliable and rock stable and 3) still able to build complex applications with all their (seemingly) quirky needs. It's not only about having simple processes, but also about splitting the complex problem in an intelligent way, so the simple processes have simple interfaces and simple (and few!) interactions. Otherwise, the orchestrating itself becomes the main application, and may easily become even more complex than a monolithic approach would have been.
- gyepi 13y agoAs of today, there is no build system which is 1) simple and easily comprehensible, 2) reliable and rock stable and 3) still able to build complex applications with all their (seemingly) quirky needs. See https://github.com/gyepisam/redux https://github.com/gyepisam/redux It's an implementation of DJB's redo concept. I wrote it because I needed a build tool with exactly the features you describe and none of the alternatives had them. I encourage you to try it out and provide feedback if necessary.
- vog 13y agoRedo solves some problems with reliability, which is good [1], but regarding complexity reduction and simplicity it seems to be not better than a plain Makefile. [2] Also, I don't think it is a good idea to implement this in Go, because you are limiting your userbase to those willing to install Go and willing to compile and build your stuff. From another perspective: Redo is not a tough task, so why not using a ubiquitous language such as Perl or Python? That way, it would run out of the box on almost every machine. Heck, you could even implement it in portable shell script with acceptable effort. If you ever want to establish a new build system, the entry barrier should be as low as possible. [1] But honestly, redo don't address any issue that "make clean; make" wouldn't solve. So the practical advantage is rather limited. [2] Nothing wrong with plain Makefiles, though, I use that approach successfully for many small projects.
- ryanjshaw 13y agoI think the restaurants were a poor analogy. Much better for me was the rule right at the end: > Innovate on your core product, not on your plumbing (this rule is extremely tempting for developers to break - see next rule) I was first exposed to this during my final year university project in 2004. We had a sponsor who wanted to build a marketplace for tourism operators and B&Bs. I was the only real developer on the team of 4. I worked really hard with little sleep, producing a really great caching layer and a very impressive WYSIWYG editor. But when the project deadline arrived you couldn't even book a room on the site. I still struggle with staying focused; the best technique I've discovered to deal with this is to log ALL work around a project, prioritise the tasks and stick to only working on logged tasks with the highest priorities assigned rather than do whatever I feel like. (It took me even longer to realise what a business opportunity I had lost.)
- akshatpradhan 13y agoHe should have used the analogy of Alice making an automated wait staff (e.g. waiter drones) for the restaurant. Not an amazing electrical system. I wonder how that kind of story would fair in his scenario.