code of view wasn't about catching bugs. It was a primary mechanism for knowledge transfer. When your engineers learn architecture by reading senior engineer PRs, seniors maintain context by reviewing everything, and code of view was the learning loop. It was how shared theory was built and maintained across the entire team. But AI bypasses that entire loop. The code shows up, it works, it gets merged, but nobody learned anything. Nobody built context. Nobody can debug at a 3AM without reprompting the AI. And code of view was never about catching bugs. It was always about building shared understanding. AI skipped the most important step.

Another limitation in this implementation is that passing other options in the shebang to vite-node won't work, as I expect exact indexes in order to figure out what are the arguments to forward. It's not perfect but I think it's good enough to unblock people like me as a start. 👍

Another problem is that now your business logic is obfuscated inside the ORM layer. If you look at the structure of the source code of a typical Rails application, all you see are these nice MVC buckets. They may reveal the domain models of the application, but you can’t see the Use Cases of the system, what it’s actually meant to do.

Rails' observers were partly inspired by aspect-oriented programming -- they're about cross-cutting concerns. If you're putting business logic in observers that is tightly coupled to the models they're observing, you're doing it wrong IMO.

I want RSpec Rails development to be fast, and lightweight, much like it was when I joined the RSpec project.

As of right now the full build takes over an hour to run, and this makes cycling for PRs and quick iterative development very difficult.

We often think of software development as a ticket-in-code-out business but this is really only a very small portion of the entire thing. Completely independently of the work done as a programmer, there exists users with different jobs they are trying to perform, and they may or may not find it convenient to slot our software into that job. A manager is not necessarily the right person to evaluate how good a job we are doing because they also exist independently of the user–software–programmer network, and have their own sets of priorities which may or may not align with the rest of the system.

It's incredibly important to test your Facebook Login flow under a variety of conditions, and we've built a robust testing plan for you to follow.

As our app grows, an increasing amount of random code is landing in the app/services directory. I'm worried it will become impractical to improve on this, as the number of special cases will only increase. Some pain points off the top of my head (definitely not exhaustive):

I'm assuming some of the goals are to make it clear where to put new files (and to stay within current Rails conventions). We already have a few non-standard app folders in our project, such as app/services, app/queries, etc. and we put some non-ActiveRecord classes in app/models. If we are going to move files, it might make sense to first define where files should go, and then move each file to the appropriate place. This might be more of a reorganization project, than copying over a folder.

How to set up and validate locally Access content editor in wikis or in issues behind a feature flag :content_editor_on_issues. Copy some text from Google docs or any rich text document Press Cmd/Ctrl + Shift + V to paste raw text.

In computing, the robustness principle is a design guideline for software that states: "be conservative in what you do, be liberal in what you accept from others". It is often reworded as: "be conservative in what you send, be liberal in what you accept". The principle is also known as Postel's law, after Jon Postel, who used the wording in an early specification of TCP.

In the layered architecture pattern, each layer fulfills a specific responsibility and role within the application. Some focus on user interface logic, while others handle the execution of business rules. These layers complement each other's unique purposes, but they aren't explicitly reliant on one another to perform their own tasks.

In software architecture, layers act as individual processes within the infrastructure of an application. These layers typically form a pattern, also called the n-tier architecture pattern.

Marking methods protected by default is a mitigation for one of the major issues in modern SW development: failure of imagination.

The transition from an idea to a successful product may be challenging and full of unexpected pitfalls. Harvard Business Review states that roughly 65% of projects end up failing, wasting a lot of resources.

MACHINE LEARNING FOR STOCK PRICES FORECASTING

this intellectual background can also lead to arrogance. People who excel at software design become convinced that they have a unique ability to understand any kind of system at all, from first principles, without prior training, thanks to their superior powers of analysis. Success in the artificially constructed world of software design promotes a dangerous confidence.

Web and mobile apps, SPAs, and SAAS products with thoughtful UX and robust implementation.

Mark: Yeah. And I actually think the Agile revolution in software development is software development catching up to the fact that it’s a writer-ly art. Writers don’t know where they’re going or how they’re going to express it when they start out. Neither, it turns out, does software developers. They can pretend by writing it the first time in a spec language and then coding it and then, checking the specification, then finding out that they’ve written the wrong thing and writing a new specification. That was when I was getting started, the right way to write software.

git_workspace/ ├── .vscode │ └── settings.json # global settings, my preferred ones ├── my-personal-projects/ │ └── project1/ │ └── .git/ └── company-projects/ ├── .vscode │ └── settings.json # local settings, overrides some of my personal ones ├── project2/ │ └── .git/ └── project3/ └── .git/

I realize that having the same FE/BE on all platforms is the fabled cross-platform panacea. But I’ve yet to see this work well in practice for any app of significant complexity. Quite a few major development teams that were early adopters of ideas like this have since abandoned that approach e.g. AirBnB with React Native, or DropBox with their custom C++ core. As it turns out, while you do write less platform-specific code, you still have to deal with platform-specific bugs and performance issues (not too dissimilar from Qt, just the with additional headaches of mobile platforms). So creating one “universal” code base ends up being almost as much work as working with each platform’s native technologies.

the functional core, imperative shell pattern

For new code, it’s usually a good idea to design the code so that it’s easy to test with “real” objects, rather than stubs or mocks.

We keep our functional tests separate from our unit tests, in the tests/functional directory. Because these are slow to run, we will usually write one or two functional tests to check a new feature works in the common case, and unit tests for all the other cases.

To run the backend test suite only call tox directly

In particular, it allowed for organizing common traits (such as extensibility, or different ways of showing examples as schemas that can be mixed in to the main object definitions.

when you start with something simple but special purpose, it inevitably accretes features that attempt to increase its generality, as users run into its limitations. But the result of this evolutionary process is usually a complicated mess compared to what could be achieved by designing for generality up-front, in a more holistic way.

Debugging is the process of finding and removing errors (bugs) from a software program. Bugs occur in programs when a line of code or a statement conflicts with other elements of the code. We also call errors or defects in hardware bugs.

The intent of this specification and related tools is to expand the reach of development containers, allow the usage of containers by themselves or different orchestration technologies, and allow any tool to manage and create them.

Any software developer will recognize it, The Eureka Moment. This is when you suddenly see how to solve a particular problem. We have them in all shapes and sizes and at the strangest moments. How does that work in SCRUM and DevOps teams?

Instead read this gems brief source code completely before use OR copy the code straight into your codebase.

There are project layouts that put implementation files and test files together.

This is especially useful for UI library components, as it is generally unknown which events will be required from them for all desired use cases. For example, if a Button component only forwards a click event, then no use case that requires the mouseover or the keypress event can be used with it.

How to Create Your Own Accounting Software: Technologies and Cost

Here's a framing I like from Gary Bernhardt (not set off in a quote block since this entire section, another than this sentence, is his). People tend to fixate on a single granularity of analysis when talking about efficiency. E.g., "thinking is the most important part so don't worry about typing speed". If we step back, the response to that is "efficiency exists at every point on the continuum from year-by-year strategy all the way down to millisecond-by-millisecond keystrokes". I think it's safe to assume that gains at the larger scale will have the biggest impact. But as we go to finer granularity, it's not obvious where the ROI drops off. Some examples, moving from coarse to fine: The macro point that you started with is: programming isn't just thinking; it's thinking plus tactical activities like editing code. Editing faster means more time for thinking. But editing code costs more than just the time spent typing! Programming is highly dependent on short-term memory. Every pause to edit is a distraction where you can forget the details that you're juggling. Slower editing effectively weakens your short-term memory, which reduces effectiveness. But editing code isn't just hitting keys! It's hitting keys plus the editor commands that those keys invoke. A more efficient editor can dramatically increase effective code editing speed, even if you type at the same WPM as before. But each editor command doesn't exist in a vacuum! There are often many ways to make the same edit. A Vim beginner might type "hhhhxxxxxxxx" when "bdw" is more efficient. An advanced Vim user might use "bdw", not realizing that it's slower than "diw" despite having the same number of keystrokes. (In QWERTY keyboard layout, the former is all on the left hand, whereas the latter alternates left-right-left hands. At 140 WPM, you're typing around 14 keystrokes per second, so each finger only has 70 ms to get into position and press the key. Alternating hands leaves more time for the next finger to get into position while the previous finger is mid-keypress.) We have to choose how deep to go when thinking about this. I think that there's clear ROI in thinking about 1-3, and in letting those inform both tool choice and practice. I don't think that (4) is worth a lot of thought. It seems like we naturally find "good enough" points there. But that also makes it a nice fence post to frame the others.

As with this post on reasons to measure, while this post is about practical reasons to improve productivity, the main reason I'm personally motivated to work on my own productivity isn't practical. The main reason is that I enjoy the process of getting better at things, whether that's some nerdy board game, a sport I have zero talent at that will never have any practical value to me, or work. For me, a secondary reason is that, given that my lifespan is finite, I want to allocate my time to things that I value, and increasing productivity allows me to do more of that, but that's not a thought i had until I was about 20, at which point I'd already been trying to improve at most things I spent significant time on for many years.

A specific example of something moving from one class of item to another in my work was this project on metrics analytics. There were a number of proposals on how to solve this problem. There was broad agreement that the problem was important with no dissenters, but the proposals were all the kinds of things you'd allocate a team to work on through multiple roadmap cycles. Getting a project that expensive off the ground requires a large amount of organizational buy-in, enough that many important problems don't get solved, including this one. But it turned out, if scoped properly and executed reasonably, the project was actually something a programmer could create an MVP of in a day, which takes no organizational buy-in to get off the ground. Instead of needing to get multiple directors and a VP to agree that the problem is among the org's most important problems, you just need a person who thinks the problem is worth solving.

Unlike most people who discuss this topic online, I've actually looked at where my time goes and a lot of it goes to things that are canonical examples of things that you shouldn't waste time improving because people don't spend much time doing them. An example of one of these, the most commonly cited bad-thing-to-optmize example that I've seen, is typing speed (when discussing this, people usually say that typing speed doesn't matter because more time is spent thinking than typing). But, when I look at where my time goes, a lot of it is spent typing.

It is commonly accepted, verging on a cliche, that you have no idea where your program spends time until you actually profile it, but the corollary that you also don't know where you spend your time until you've measured it is not nearly as accepted.

I'm not a naturally quick programmer. Learning to program was a real struggle for me and I was pretty slow at it for a long time (and I still am in aspects that I haven't practiced). My "one weird trick" is that I've explicitly worked on speeding up things that I do frequently and most people have not.

Everything a Product Owner Needs to Know Before Starting a Software Development Project

I always had to set the height of them literally almost 50% taller than the content itself to accommodate for the innards growing when the form was submitted with errors (the error messaging expanded the height). If I didn’t, the submit button would get cut off making the form un-submittable.

Custom Software Development

This works nicely wherever we show authors, but after we deploy to production, the folks from other parts of the world won’t get notified anymore about their songs. Mistakes like these are easy to make when using concerns.

A litmus test on whether an option belongs to adapter config or kit config, would be to ask whether the option becomes irrelevant when you switch the adapter to static.

CSS seems like the right place to put visual information. On the other hand, few would argue that image "src" should not be specified as an attribute and the height/width seem as tied to the binary image data as the "src" is.

Clubhouse has really made a fuss around the digital world. It’s hard to imagine a person who hasn’t heard about this app, celebrities who joined it, or pranksters who already managed to confuse the audience. Taking into account the skyrocketing popularity, “how to make an app like Clubhouse” has become an urgent question in the software development business. 

You might not always notice, but Material Design is constantly evolving and iterating based on research.

Write modules that solve a problem you know

Want to know how to build a taxi app that will become the next Uber or Carb? It is a reasonable question considering how convenient and cost-effective it is to use a taxi instead of maintaining your own vehicle. The best way for a cab company to ensure this convenience for customers is to build a taxi booking app.

How do you know if source maps are working correctly? Try adding a syntax error to one of your assets and use the console to debug. Does it show the correct file and source location? Or does it reference the top level application.js file?

I started Trailblazer GmbH 4 years ago with my relocation from Australia back to Europe. One of our consulting clients is the central police department of a German state that has kept me busy for more than three years now.

which entails computer programming (process of writing and maintaining the source code), but also encompasses a planned and structured process from the conception of the desired software to its final manifestation

Whether this is the life-cycle of a <user> entity or just a sign-up function, it has to be defined and coded somewhere.

Trailblazer extends the conventional MVC stack in Rails. Keep in mind that adding layers doesn't necessarily mean adding more code and complexity. The opposite is the case: Controller, view and model become lean endpoints for HTTP, rendering and persistence. Redundant code gets eliminated by putting very little application code into the right layer.

Trailblazer offers you a new, more intuitive file layout in applications.

Instead of grouping by technology, classes and views are structured by concept, and then by technology. A concept can relate to a model, or can be a completely abstract concern such as invoicing.

ActiveInteraction plays nicely with Rails. You can use interactions to handle your business logic instead of models or controllers.

Why is all this interaction code better? Two reasons: One, you can reuse the FindAccount interaction in other places, like your API controller or a Resque task. And two, if you want to change how accounts are found, you only have to change one place.

We could quite easily create a model class that isn’t based on ActiveRecord and have it work as Rails is quite decoupled from ActiveRecord, but there are advantages to keeping our model class inheriting from ActiveRecord.

Programming to interfaces is at the core of flexible structure.

With the introduction of CPUs which ran faster than the original 4.77 MHz Intel 8088 used in the IBM Personal Computer, programs which relied on the CPU's frequency for timing were executing faster than intended. Games in particular were often rendered unplayable. To provide some compatibility, the "turbo" button was added. Engaging turbo mode slows the system down to a state compatible with original 8086/8088 chips.

The problem with this is that it creates a strong coupling between your code and the implementation, exactly what the interface was supposed to prevent.

Top level architecture

Unlike naming children, coding involves naming things on a daily basis. When you write code, naming things isn’t just hard, it’s a relentless demand for creativity. Fortunately, programmers are creative people.

Systemd flies in the face of the Unix philosophy: 'do one thing and do it well,' representing a complex collection of dozens of tightly coupled binaries

How should this be manually tested?

It must be called during the component's initialisation (but doesn't need to live inside the component; it can be called from an external module).

While the code may live online somewhere forever, an open source project only truly survives if someone maintains it.

artificial intelligence seems to be the future of software

We are unapologetic tinkerers who neither invent the wheel, nor are satisfied with the wheels already at our disposal. The best scholarship and the best pedagogy take the best of what already exists and make it better, at least better for the task at hand. We need to embrace this identity as hackers, acknowledge our indebtedness to those who have gone before us, forsake the illusion that we are creating (can create, should create) something wholly original, but also refuse to take for granted the things that have been passed down to us.

We usually only see people launching projects once they're already done. I'm sure there are countless more unfinished and unlaunched side projects that the world will never know about. Don't let your side project become one of them.

Keep in mind that as a software developer, of any degree, learning is continuous. New technologies, new ways to write code, not so new approaches, persisting patterns. Read books, watch online courses, follow tutorials, keep learning!

A Comprehensive Guide on the Dedicated Team Model: Explaining the Concept, Advantages, and Pitfalls

I'm still deeply working on it every day, i'm around 1/2 month away for a first preview release.

The project organization is a bit weird because we have a mono-repository that contains projects and libraries. The projects are grouped by company and by browser / server / universal.

Since yarn already has retries on metadata operations, my perspective is that this PR is about filling in an (inadvertent I assume) gap.

Test plan You need a large NPM package in a private org on the npmjs.org registry. 10MB download size is ideal.

In my opinion, deleting a user is not a function executed by an item on itself but is a function done by the holder of the array. So in your case you would be better of moving the deleteUser up to App.

If you want to implement a form with a superb User Experience, you have to take care of many variables:

you took 4 hours to respond, so I implemented it myself

Yeah I see what you're saying. In my case, I had a group of classes that relied on each other but they were all part of one conceptual "module" so I made a new file that imports and exposes all of them. In that new file I put the imports in the right order and made sure no code accesses the classes except through the new interface.