IMO: one of the biggest problems in modern softwaredevelopment• Code breaks constantly, even if it doesn’t change• Huge cause of reliability issues and time wasted• This is somehow accepted as normal

The program will compile, but not run, because JVM will not recognize the main() method. Remember JVM always looks for the main() method with a string type array as a parameter.

An object in Java is the physical as well as a logical entity, whereas, a class in Java is a logical entity only.

Many popular SQL clients do not use SSL by default. If you aren’t deliberate about choosing encryption, the connection will be unencrypted.

SSL is disabled by default in jdbc, npgsql, node-postgres, and pgx.

The best book that I can recommend to any developer to shape up their attitude about programming.

I said I wanted begin..end to follow the same indentation principles as if..end because they are semantically related (both are expressions), and I stand by that opinion.

really begin/end is just a way to pass several expressions where you normally need to pass only one. In this way I think it's much closer to something like conditionals (e.g. if, than to do).

I have a simple coding principle: write lines of code as though instructing a real person how to do the job. And that naturally expands to designing and modelling systems like real organisations with their own divisions, departments, branches, and all the various “job positions” that need to be filled. Make the whole system appear as human as possible.

A line of code containing 6+ pieces of information should be simplified.

That’s why it was such a life-changing event for me when I found Dash in 2012.

allOf takes an array of object definitions that are validated independently but together compose a single object.

You have stumbled upon the most common problem in JSON Schema, that is, its fundamental inability to do inheritance as users expect; but at the same time it is one of its core features.

Also be aware of how Ruby handles aliases and inheritance: an alias references the method that was resolved at the time the alias was defined; it is not dispatched dynamically.

For example, whereas C programmers have argued for years about where to put their brackets, and whether code should be indented with tabs or spaces, both Rust and Go eliminate such issues completely by using a standard formatting tool (gofmt for Go, rustfmt for Rust) which rewrites your code automatically using the canonical style. It’s not that this particular style is so wonderful in itself: it’s the standardisation which Rust and Go programmers appreciate.

If you like the functional style of programming, though, you’ll find a lot more facilities for it in Rust, because Rust has a lot more facilities than Go in general.

The LISP part, though, is not going well. Porting clever 1970s Stanford AI Lab macros written on the original SAIL machine to modern Common LISP is hard. Anybody with a knowledge of MACLISP want to help?

Ruby's keyword args work a little differently than similar implementations (selectors in Objective C, for instance). The value on the right-hand side of the colon is the default, not the local name.

When you run a command like python or pip, your operating system searches through a list of directories to find an executable file with that name. This list of directories lives in an environment variable called PATH, with each directory in the list separated by a colon: /usr/local/bin:/usr/bin:/bin Directories in PATH are searched from left to right, so a matching executable in a directory at the beginning of the list takes precedence over another one at the end. In this example, the /usr/local/bin directory will be searched first, then /usr/bin, then /bin.

Now, not every programmer prefers that kind of development. Some programmers prefer to think of development as a process of designing, planning, making blueprints, and assembling parts on a workbench. There’s nothing wrong with that. Indeed, a multibillion-dollar international industry has been built upon it.

In fact, there’s a style of programming, well known in Lisp and Smalltalk circles, in which you define a toplevel function with calls to other functions that don’t yet exist, and then define those functions as you go in the resulting breakloops. It’s a fast way to implement a procedure when you already know how it should work.

Moreover, because the entire language and development system are available, unrestricted, in the repl, you can define the missing function bar, resume foo, and get a sensible result.

I find C++ quite ugly

When a person uses a tool to achieve some goal, they quickly learn how towork around the short-comings of the tool in order to get their job done. As a result, the personbecomes desensitized to problems in the tool.

Mob requires good communication skills. There is no space for passive-aggressiveness; or arrogance. If You want to show You are better than Your colleagues, You aren’t a candidate for Mob.

It should be dead simple to distribute content (eg. static content).It should be easy to build apps.It should be not too hard to build a platform.

Dynamic typing makes that harder

In computing, serialization (US and Oxford spelling) or serialisation (UK spelling) is the process of translating a data structure or object state into a format that can be stored (for example, in a file or memory data buffer) or transmitted (for example, over a computer network) and reconstructed later (possibly in a different computer environment).[1] When the resulting series of bits is reread according to the serialization format, it can be used to create a semantically identical clone of the original object. For many complex objects, such as those that make extensive use of references, this process is not straightforward. Serialization of object-oriented objects does not include any of their associated methods with which they were previously linked.

Most notably missing from the discussion is inheritance.

What is not OK is what I perceive as the dominant attitude today: sell SciPy as a great easy-to-use tool for all scientists, and then, when people get bitten by breaking changes, tell them that it’s their fault for not having a solid maintenance plan for their code.

An ActivePaper is, by defini-tion, a package combining the code, data, and documentationthat describe together a computational scientific study.

What I call software collapse is what is more commonly referred to as software rot: the fact that software stops working eventually if is not actively maintained. The rot/maintenance metaphor is not appropriate in my opinion because it blames the phenomenon on the wrong part. Software does not disintegrate with time. It stops working because the foundations on which it was built start to move.

“on a decadal time scale, wecannot rely on software to run repeatably.

I can't possibly keep updating software to deal with new JavaScript versions

and free of globals

There are no static variables and no initialization

#Software #Hardware #Technology #Programming #Internet #Web Development #Data #Beginner Tutorial #Computer Science #Computers #Engineering

Later in life and irrespective to the character of the relationship held, the good enough approachinforms how communication between people can be practiced. One of the widest known formulasfor that is called Nonviolent Communication, subtitled as the ‘language of life’ [ 39]. The subtitle seemsparticularly appropriate to our case, as it describes a method of communication that does not servesocial programming and allow humans to author and own their speech. A nonviolent communicatordoes not reinforce the boundary cuts and refrains from installing the personware-shaping doublebinds.

delegate :name, :to => :department, :prefix => true, :allow_nil => true

von neumann was furious at him furious that he would waste precious machine time 00:04:20 doing the assembly that was clerical work that was supposed to be for people right and so we saw the same story happened just a little bit later when john backus and friends came up with us idea they called fortran this is so call high-level language where you could write out your formulas as if your writing mathmatical notation you could write out loops and this was shown to the assembly programmers and once again they just 00:04:46 they weren't interested they don't see any value in that they just didn't get it so um I want you to keep this in mind as I talk about the four big ideas that I'm going to talk about today that it's easy to think that technology technology is always getting better because Moore's law because computers are getting always more capable but ideas that require people to unlearn what they've learned and think in new ways there's often 00:05:10 enormous amount of resistance people over here they think they know what they're doing they think they know a programming is this programming that's not programming and so there's going to be a lot of resistance to adopting new ideas

In computer programming, Intentional Programming is a programming paradigm developed by Charles Simonyi that encodes in software source code the precise intention which programmers (or users) have in mind when conceiving their work. By using the appropriate level of abstraction at which the programmer is thinking, creating and maintaining computer programs become easier. By separating the concerns for intentions and how they are being operated upon, the software becomes more modular and allows for more reusable software code

Intentional programming

// NB: Since line terminators can be the multibyte CRLF sequence, care // must be taken to ensure we work for calls where `tokenPosition` is some // start minus 1, where that "start" is some line start itself.

getLineStart(tokenPosition, anteTerminators = null) {
  if (tokenPosition > this._edge && tokenPosition != this.length) {
    throw new Error("random access too far out"); // XXX
  }

  // NB: Since line terminators can be the multibyte CRLF sequence, care
  // must be taken to ensure we work for calls where `tokenPosition` is some
  // start minus 1, where that "start" is some line start itself.
  for (let i = this._lineTerminators.length - 1; i >= 0; --i) {
    let current = this._lineTerminators[i];
    if (tokenPosition >= current.position + current.content.length) {
      if (anteTerminators) {
        anteTerminators.push(...this._lineTerminators.slice(0, i));
      }
      return current.position + current.content.length;
    }
  }

  return 0;
}

In terms of this analogy, a lot of objections to end-user programming sound to me like arguing that Home Depot is a waste of time because their customers will never be able to build their own skyscrapers. And then on the other side are the people arguing that people will be able to build their own skyscrapers and it will change the world. I just think it would be nice if people had the tools to put up their own shelves if they wanted to.

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.

Review: a formal assessment or examination of something with the possibility or intention of instituting change if necessary.

YouArentGonnaNeedIt (often abbreviated YAGNI, or YagNi on this wiki) is an ExtremeProgramming practice which states: "Always implement things when you actually need them, never when you just foresee that you need them."

But to my knowledge, this is the first time anyone has collected public info about Bigco dev environments in one place

The fundamental mistake of Node.js was diverging from the browser

It is NOT an exception if the username is not valid or the password is not correct. Those are things you should expect in the normal flow of operation. Exceptions are things that are not part of the normal program operation and are rather rare.

Exceptions should be reserved for what's truly exceptional.

Make sure the exceptions are at the same level of abstraction as the rest of your routine.

Don't use exceptions if the error can be handled locally

Use exceptions to notify about things that should not be ignored.

if the function's assumptions about its inputs are violated, it should throw an exception instead of returning normally.

I think RSpec should provide around(:context)/around(:all). Not because of any particular use case, but simply for API consistency. It's much simpler to tell users "there are 3 kinds of hooks (before, after and around) and each can be used with any of 3 scopes (example, context and suite)". Having some kinds of hooks work with only some kinds of scopes makes the API inconsistent and forces us to add special case code to emit warnings and also write extra documentation for this fact.

I've been thinking of looking into implementing this in rspec-core, primarily to make the API more consistent (e.g. so that you can combine any scope -- example/context/suite -- with any hook type before/after/around).

Javascript is severely restricted in file:// today.

Knuth recommended getting familiar with the program by picking up one particular part and "navigating" the program to study just that part. (See https://youtu.be/D1jhVMx5lLo?t=4103 at 1:08:25, transcribed a bit at https://shreevatsa.net/tex/program/videos/s04/) He seems to find using the index (at the back of the book, and on each two-page spread in the book) to be a really convenient way of "navigate" the program (and indeed randomly jumping through code, as you said), and he thinks that one of the convenient things about the "web" format is that you can explore it the way you want. This is really strange (to us) as the affordances we're used to from IDEs / code browsers etc are really not there

With every generation of computing comes a dominant new software or hardware stack that sweeps away the competition and catapults a fledgling technology into the mainstream.I call it the Canonical Stack (CS).Think the WinTel dynasty in the 80s and 90s, with Microsoft on 95% of all PCs with “Intel inside.” Think LAMP and MEAN stack. Think Amazon’s S3 becoming a near universal API for storage. Think of Kubernetes and Docker for cloud orchestration.

By offering to have a real-time technical discussion, you are reframing the code review process away from an 'instructor correcting student' dynamic and into a 'colleagues working together' mindset.

Level 5: Stop the line. The highest level of code review comments. Borrowing the term from Toyota's manufacturing process this is when the code reviewer noticed something in the PR that signals a major defect.

Level 4: Infringement. This is where things get more serious, note that infringement means rules were broken. In this context, rules can mean a number of things, from the more obvious feature spec and framework rules to things like style guides and coding principles.

Level 3: Suggestions. These can also be thought of as recommendations and alternatives.

Level 2: Nitpicks. Usually, comments about grammar errors and minor stylistic issues/typos go there. The solution to the nitpicks is usually very obvious and if the solution is opinionated, the opinion is not strongly held. Naming a method foobarGenerator vs foobarFactory goes in here, and nitpick comments often start with Nitpick:.

Level 1: Clarifications. I also think of these as sanity checks, I may even start the comment with something like I may be completely off the base here... or Just to sanity check...

The problem is that a lot of old school website devs can write jQuery and very very little actual JavaScript.

now something breaks elsewhere that was unsuspected and subtle. Maybe it’s an off-by-one problem, or the polarity of a sign seems reversed. Maybe it’s a slight race condition that’s hard to tease out. Nevermind, I can patch over this by changing a <= to a <, or fixing the sign, or adding a lock: I’m still fleshing out the system and getting an idea of the entire structure. Eventually, these little hacks tend to metastasize into a cancer that reaches into every dependent module because the whole reason things even worked was because of the “cheat”; when I go back to excise the hack, I eventually conclude it’s not worth the effort and so the next best option is to burn the whole thing down and rewrite it…but unfortunately, we’re already behind schedule and over budget so the re-write never happens, and the hack lives on.

as if the only option we had to eat was factory-farmed fast food, and we didn’t have any way to make home-cooked meals

If you’re a coder, when’s the last time you just quickly built something to solve a problem for yourself or simply because it was a fun idea?

This column will continue only if I hear from people who use literate-programming systems that they have not designed themselves. and it did not continue.

To keep tiny mistakes from crashing our software or trashing our data, we write more software to do error checking and correction.

suppose when you needed to make a permanent edit to the style sheet on your homepage, you opened up the CSS viewer, made the edit, and the result persists—not just in your browser, but by changing the very style sheet itself

an acknowledgement of network effects: LP is unlikely to ever catch on enough to be the majority, so there needs to be a way for a random programmer using their preferred IDE/editor to edit a "literate" program

in other words, there would be no "weave" step

memory usage and (lack of) parallelism are concerns

local a (e.g. aPoint) param p (e.g. pPoint) member instance m (e.g. mPoint) static s (e.g. sPoint)

This can get much worse than the above example; the number of \’s required is exponential in the nesting depth. Rc fixes this by making the backquote a unary operator whose argument is a command, like this: size=‘{wc -l ‘{ls -t|sed 1q}}

for parsing and converting a superset of Markdown

We overload the meaning of "GFM" to mean "GitLab Flavored Markdown", which is a superset of GitHub's version. However it can cause confusion as they are not the same thing.

The argument used to propose its use is to avoid the construction of multiple volatile objects. This supposed advantage is not real in virtual machines with efficient garbage collection mechanisms.

When creating a singleton, the author is making the assumption that no program will ever have any reason to have more than one instance of the class.  This is a big assumption, and it often proves wrong later on when the requirements change.

Avoid singletons from the start.

Stop using TODO for everything in your comments that requires you to do something later.

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

I'm not sure what $name is

comparing the event and window.event isn't enough to know if event is a variable in scope in the function or if it's being looked up in the window object

Then, if the string can be represented as ASCII, only one byte of memory is used per character. If the string uses more extended characters, it might end up using as many as 4 bytes per character. We can see how much memory an object needs using sys.getsizeof()

I feel like better code visualization would solve a lot of my problems. Or at least highlight them.

The Code Review Pyramid

Let’s look at a recent paper by Xia, Bao, Lo, Xing, Hassan, & Li entitled Measuring Program Comprehension: A Large-Scale Field Study with Professionals and published in IEEE Transactions on Software Engineering, 44, 951-976, 2018. This paper is quite interesting in that it describes in great details how the figures are obtained. And it says that Comprehension took on average ~58%.

The SE server is also responsible for building ebooks when they get released or updated. This is done using our ebook production command line toolset.

# Input Input: 123, Output: Input: 121, Output: Input: 111, Output: Input: 123454321, Output: Input 123123, Output: # Instruction Output true if input is a palindrome # Output Input: 123, Output: false Input: 121, Output: true Input: 111, Output: true Input: 123454321, Output: true Input 123123, Output: false

software will work only if we provide the tools to fix it when it goes wrong

Using named arguments is nice for languages that support it, but this is not always a possibility. Even in Python, where time.sleep is defined with a single argument named secs, we can’t call sleep(secs=300) due to implementation reasons. In that case, we can give the value a name instead.Instead of this:time.sleep(300)Do this:sleep_seconds = 300 time.sleep(sleep_seconds)Now the code is unambiguous, and readable without having to consult the documentation.

Core: like an engine in a car. The product is meaningless without it.Necessary: like a car’s spare wheel. It’s rarely used but when needed, its function decides the success of the system.Added value: like a car’s cup-holder. It’s nice to have but the product is perfectly usable without it.Unique Selling Point: the main reason people should buy your product instead of your rivals. For example, your car is the best off-road vehicle.

front-end dumpster fires, where nothing that is over 18 months old, can build, compile or get support anymore. In my day job, I inherit "fun" tasks as 'get this thing someone glued together with webpack4 and frontend-du-jour to work with webpack5 in 2022

Literate programs allow you to answer these questions naturally.

In 1994, The Unix-Haters Handbook was published containing a long list of missives about the software—everything from overly-cryptic command names that were optimized for Teletype machines, to irreversible file deletion, to unintuitive programs with far too many options. Over twenty years later, an overwhelming majority of these complaints are still valid even across the dozens of modern derivatives. Unix had become so widely used that changing its behavior would have challenging implications. For better

Object hierarchies are very different from relational hierarchies. Relational hierarchies focus on data and its relationships, whereas objects manage not only data, but also their identity and the behavior centered around that data.