Ever had a script you just can’t scratch? Try Excel on the web's new and improved method to get rid

Echoing PBL's comment above, using an external set of scripts to drive the spreadsheet is much more performant, allows all sorts of technologies that are just bolt-ons to Excel, and are capable of being audited. For me storing scripts in a git/svn repository and seeing the version differences is immensely important.

Except there are valid times when you may want to pull several files in using a macro, or perhaps just reading data from those files. So I think being unable to read files or perform some system-level tasks; such as renaming, deleting, moving, or executing files; would hinder some use valid cases.

Ever had a script you just can’t scratch Excel on the web now has just the thing

DOWNLOAD: https://urluss.com/2vECed

There is nothing like a panacea tool. I see a lot of people talking about Vim as the only needed tool but clearly this is not universal among developers needs, many times you will just need deeper deployment, analysis, debugging, etc. This apply for OSes too, nowadays not all developers can afford only focusing their knowledge on a single platform or technology.

If you want me to switch to your editor, and tempt me with a vim mode, then you need to give me something in return. All the plugins I have fancied in VSCode or Atom has equivalents in vim either by plugins or just being native. And the only thing can see being awesome in VSCode over both Atom and vim is the git integration. But again just using the git cli gives me more features, and allows me to simply type in what I want into my shell, and it will be done. No fiddling with the mouse, being in the dismay of the UX designer of VSCode. VSCode and Atom are not like the new Playstation, where I need to purchase the new system to be allowed access to buy the new games. VSCode and Atom are trying to take the fundamental graphical editor, designed for the computer illiterate person who does not want to learn how to command the computer, and tacking on programming helping features. This is great, I would have loved to have VSCode when I was in elementary school writing my first programs in notepad.exe, but today I am in a position where I can learn a new program if it saves me at least the time spent learning.

I also once tried Atom, which was unbearably slow to just start up. I probably would use an IDE if I worked on something that requires tight toolchain integration, like Java/Android or iOS development.

I was surprised with how good it was as an IDE. Autocomplete worked just like in VS Code, syntax check was better (because the EC2 instance is very very fast), go to definition and find references worked like a charm. It took me a while to make it work like I wanted it to (I like to config small details to my liking), and the only thing that still sucks is Java development with Bazel: IDEA is still the only feasible choice. But for JS and Python development, Vim is pretty good.

IDEs should help you but not dictate how to make things work. The trouble with IDEs like visual studio is that they create solutions for you then behind the scenes would add alot of scaffolding just to make things work. In time these scaffolding will be obsolete and may cause compatibility issues. Instead of worrying about the feature program we end up worrying about the scaffolding. The good thing about lower level IDEs or just plain editors is that nothing is hidden from you and you would clearly understand what is going on.

Regular expressions use special characters called metacharacters to denote different patterns. For instance, the asterisk character (*) stands for zero or more instances of whatever comes just before the asterisk.

While I no longer work on this project [funding, politics, blah blah], I think it gave me some enormous insight into how bad some projects can be written, and steps one developer can take to make things a lot cleaner, readable and just flat out better with small, incremental steps over time.

That's an important point: it costs money to write something from scratch. How will you recoup that money? Many programmers ignore this point simply because they don't like the code--sometimes with justification, sometimes not.

I have been part of a small dedicated team that has rewritten code from scratch including reverse engineering business rules of the earlier code. The original application was web service written in C++ (with regular crashes and severe memory leaks) and a ASP.Net 1.0 web application and the replacement was a C# 2.0 asmx based web service and an ASP.Net 2.0 web application with Ajax. That said some of the things the team did and explained to management

I've had to rewrite a codebase from scratch, and it had to do with politics. Basically, the previous coder who managed the codebase was too embarrassed to release the source code to the new team that had just been hired. She felt that every criticism of the code was a criticism of her as a person, and as a result, she only released code to the rest of us when she was forced. She is the only person with administrative access to the source repository, and whenever she's been asked to release all the source, she's threatened to quit and take all of her knowledge of the code and go home.

After a while you will have migrated some 60% of the code base to use the new back-ends without the work being an official project, just maintenance, so you will be in a better position to argue for development time to do the other 40%, and once that is done the existing front-end classes will be vastly reduced in size and complexity. Once it is fully migrated, you will be able to reuse the new back-end model and controller components if you ever get the time to implement a new view.

I've spent most of my career inheriting steaming piles of dung we politely called "programs", written by young, inexperienced programmers who were considered "rock stars" by the managers. These things are generally unfixable, and you end up spending 10 times as much effort keeping them limping along as you would have spent just rewriting them from the ground up.

Going back to Joel's essay, he talks about code that's messy, but software that is reliable and delivers the expected value. If instead, you have unreliable code full of major bugs and that wasn't covering all your use cases. You had things that were supposed to be there yet don't work, or are just missing. In this case, all the little hairs growing out of it aren't bug fixes, but cancer.

Then there is the whole concept of technical debt, which, just like financial debt, CAN and WILL accrue to the point that a codebase becomes technically insolvent. More and more time and resources are invested into troubleshooting bugs, extinguishing fires, and overly-challenging improvements to an extent that forward progress becomes expensive, difficult, and perilous. Projects take longer and longer due to defects and being pulled off of project work to fix production issues. After hours "incidents" start becoming expected operation instead of some rare blip. Instead of stepping back and starting to do things right to increase our future productivity (and quality of life), we find ourselves in a position where we are forced to add more and more technical debt in order to meet deadlines - the technical equivalent to taking cash advances on a credit card to make a minimum payment on another card.

This quote from Romeo and Juliet by William Shakespeare sounds nice, and it is true from one angle. If everyone agreed that, from now on, a rose was going to be called dung, then we could get over it and it would smell just as sweet. The problem is that if, when building a database for a florist, the designer calls it dung and the client calls it a rose, then you are going to have some meetings that sound far more like an Abbott and Costello routine than a serious conversation about storing information about horticulture products.

Names, while a personal choice, are the first and most important line of documentation for your application. I will not get into all of the details of how best to name things here- it is a large and messy topic. What I want to stress in this article is the need for consistency. The names you choose are not just to enable you to identify the purpose of an object, but to allow all future programmers, users, and so on to quickly and easily understand how a component part of your database was intended to be used, and what data it stores. No future user of your design should need to wade through a 500 page document to determine the meaning of some wacky name.

As you can see, this is far from being a natural join. It comes down to the problem of mixing apples with oranges. At first glance, domain tables are just an abstract concept of a container that holds text. And from an implementation centric standpoint, this is quite true, but it is not the correct way to build a database. In a database, the process of normalization, as a means of breaking down and isolating data, takes every table to the point where one row represents one thing. And each domain of values is a distinctly different thing from all of the other domains (unless it is not, in which case the one table will suffice.). So what you do, in essence, is normalize the data on each usage, spreading the work out over time, rather than doing the task once and getting it over with.

Stored procedures can provide specific and granular access to the system. For example, you may have 10 stored procedures that all update table X in some way. If a user needs to be able to update a particular column in a table and you want to make sure they never update any others, then you can simply grant to that user the permission to execute just the one procedure out of the ten that allows them perform the required update.

And this list could go on and on. There are drawbacks too, because nothing is ever perfect. It can take longer to code stored procedures than it does to just use ad hoc calls. However, the amount of time to design your interface and implement it is well worth it, when all is said and done.

Maybe it's foolish to begin interviewing a programmer without looking at their code first. At Vertigo, we require a code sample before we even proceed to the phone interview stage. And our on-site interview includes a small coding exercise. Nothing difficult, mind you, just a basic exercise to go through the motions of building a small application in an hour or so. Although there have been one or two notable flame-outs, for the most part, this strategy has worked well for us. It lets us focus on actual software engineering in the interview without resorting to tedious puzzle questions. 2ff7e9595c