Airbrake blog posts

As the digital landscape rapidly evolves, testing software becomes as necessary as Elon Musk leaving Twitter. To ensure applications are up-to-date, developers apply dynamic development methodologies to their software life cycles. But rather than rolling the dice and measuring software at the end of its development process, companies are embracing an iterative testing approach to a software development life cycle (SDLC).

Today, we want to share with you a new way of developing code that has been gaining traction lately, sometimes referred to as : prompt engineering. 

“Any application that can be written in JavaScript, will eventually be written in JavaScript." - Jeff Atwood

With everyone talking about ChatGPT and the amazing things that AI is capable of, Python is having a moment (not that it wasn’t pretty popular before 😉). But that’s not the only reason why we’re hyped about Python. 

Recently, Golang released their “Go Developer Survey 2022 Q2 Results” showing some essential insights about Go. One insight in particular caught our eye: around 11% of Golang users struggle with error handling and working with stack traces, ranking it as their biggest challenge that they personally face using Go today. If you happen to be one of those developers, don’t worry, because Airbrake has your back! 

Since its release, Airbrake Performance Monitoring has released support for Rails, Node.js, Golang, and Python. Now we’re thrilled to announce Airbrake Performance Monitoring for Java! 

Ruby on Rails (RoR) is a framework written in the Ruby language. Since its release in 2004, it has been used by heavy-hitting companies such as Twitter, Shopify, and AirBnB. While RoR has proven itself to be a great language for building incredible applications, some developers might be wondering if RoR is a good machine learning language. In this article, we’ll list the pros and cons of RoR as a machine learning language and how these pros outweigh the cons. 

It’s been a tough time to be in tech. If you’ve been on Twitter lately, you know all about the major tech layoffs. That’s why we created this guide. We wanted to craft a list of resources and advice to help you in your job search as a developer. 

As we outlined in the previous blog post “top serverless platforms to deploy your react app”, there is a lot happening in the space of developer tools. Especially in the workflow around writing and deploying code. One workflow that’s gaining traction: Replit. 

Expanding on our previous article that covered Object-Oriented Analysis and Design (OOAD), today’s article will explore domain-driven design (DDD). DDD is a software development approach that uses and builds upon OOAD principles and ideas, so it’s the next logical topic for us to dive into.

Errors are already a nightmare, but they’re not the only thing keeping developers up at night (Thanks, PagerDuty). As a developer, some of your worst fears may include servers going down, losing all your data, or latent errors, to name a few. 

Introduction

Platforms are quickly evolving, and new ones are emerging as the industry is helping to unleash the creative powers of React developers by removing the burden of Ops from their plates. So, it only makes sense that you want to know the best serverless platform as a service (PaaS) for your aspiring React project as a developer. 

Every job comes with some element of fear. For developers, that fear could be deployments. Anytime you push new code out into production, there’s always a chance of bugs, even if you tested it thoroughly in staging. 

Introduction

At Airbrake, our goal is to give your development team the tools they need to deploy fearlessly. That’s why we’re releasing three new packages: Pro, Basic, and Developer. If you’re already an Airbrake user, you’re probably already familiar with Basic and Developer, but Pro offers some new and exciting features.

The 406 Not Acceptable is an HTTP response status code indicating that the client has requested a response using Accept- headers that the server cannot fulfill. 

The 404 Not Found Error is an HTTP response status code, which indicates that the requested resource could not be found. Like most HTTP response codes, the cause of a 404 Not Found Error can be challenging to track down and resolve. 

This article will explore the 404 Not Found Error by examining what might cause this error. Later on, we’ll provide a few tips to diagnose and debug your application’s 404 error. 

With that, let’s get started!

Introduction 

When incorporated into your company correctly, dogfooding can be a fantastic tool. It’s too bad that most companies kind of suck at it. Why might that be, you ask? Dogfooding tends to create a negative feedback loop. But, when it’s done correctly, it can be an essential tool in your technology stack. 

 A 504 Gateway Timeout Error is an HTTP response status code indicating that a server currently acting as a gateway or proxy did not receive a timely response from another server further upstream. As with most HTTP response codes, it can be challenging to determine the exact cause of a 504 Gateway Timeout Error. 

Today, we are discussing the Unexpected Token Error within our JavaScript Error Handling series. This JavaScript error is a subset of the SyntaxError. That means it only appears when attempting to execute code with an extra (or missing) character in the syntax.

In Part 1 we setup our development environment, created our twitter-bot project, integrated it with the Twitter API so it could send out programmatic tweets, and performed a basic Atom feed retrieval for some actual content to tweet.

The 400 Bad Request Error is an HTTP response status code indicating that the server was unable to process the request sent by the client due to invalid syntax. As with the dozens of potential HTTP response codes, receiving a 400 error while accessing your own application can be both frustrating and challenging to fix. 

Moving right along with our JavaScript Error Handling series, we next come to the Invalid Array Length error. The Invalid Array Length error occurs whenever an Array object has a negative length value or a value larger than the maximum.

Traveling deftly through to the next item in our JavaScript Error Handling series, today we’re taking a hard look at the JSON Parse error. The JSON Parse error, as the name implies, surfaces when using the JSON.parse() method that fails to pass valid JSON as an argument.

Today we continue our in-depth Ruby Exception Handling series with a dive into the SyntaxError exception class. A SyntexError is the fifth most common error within coding projects, according to The 2022 Airbrake Error Data Report. SyntaxError is a subclass descendant of the ScriptError superclass, and pops up anytime Ruby attempts to execute invalid code syntax.

As our journey through the  Ruby Exception Handling  series continues, today we’ll be taking a closer look at the ArgumentError. According to The 2022 Airbrake Error Data Report, the ArgumentError occurs in around 30% of all projects. ArgumentError is a descendant class of the StandardError superclass, and is typically raised when arguments passed to a method are incorrect, unexpected, or invalid in some way.

Making our way through our Ruby Exception Handling series our next stop brings us to the default raised exception class in Ruby, the RuntimeError. A RuntimeError is raised when attempting to perform an invalid operation of some kind, which doesn’t meet the criteria of a more specific error classification.

Next on the docket of our Ruby Exception Handling series is the lovable TypeError class. TypeErrors are fairly simple and are raised when an object that was passed as an argument is not of the expected type.

Continuing through our Ruby Exception Handling series, today we’ll be taking a look at the NoMethodError in Ruby. According to The 2022 Airbrake Error Data Report, the NoMethodError is the most common error within projects. As clearly indicated by the name, the NoMethodError is raised when a call is made to a receiver (an object) using a method name that doesn’t exist.

A 503 Service Unavailable Error is an HTTP response status code indicating that a server is temporarily unable to handle the request. This may be due to an overloaded server or a server that’s down for maintenance. This particular response code differs from the 500 Internal Server Error we explored some time ago. While a 500 Internal Server Error indicates an issue preventing the server from handling the request entirely, a 503 Service Unavailable Error indicates that the server is still functioning properly and can process the request, but has opted to return the 503 response code.

We would like to welcome MyFitnessPal as the 29th Airbraker in our “Awesome Airbrakers” series.

What value does your company provide?

Millions of people have lost weight with MyFitnessPal’s FREE calorie counter.

What do you like about Airbrake?

Easy to implement.
Easy to integrate with Slack.
Email reports.
Useful info to troubleshoot errors.

We would like to welcome OpenTable as the 34th Airbraker in our “Awesome Airbrakers” series.

What value does Venga bring to it’s customers?

Venga is a CRM and business intelligence platform that revolutionizes how restaurants connect with their guests.

What do you like about Airbrake?

Being notified when an error occurs in production is invaluable. Instead of combing log files looking for things out of the ordinary, we get an email pinpointing the exact thing that went wrong. This lets us respond quickly and correct the problem, hopefully before our users even notice that something went wrong.

Airbrake Performance Monitoring gives you a broad view of real application quality while allowing you to drill down into what causes slowdowns to fix performance issues fast. Super important to the “drilling down” aspect are features like our previously blogged about Performance Breakdowns which give you the duration each component (database, view, HTTP, etc) takes for the requests in a specific route. 

As part of our continued commitment to provide a the most secure platform to our customers, we are pleased to announce that Airbrake has completed a SOC 2 Type II certification under the Security Trust Principle with Cyberguard, LLP.

Last year we wrote about Three Tips to Help Optimize Your Airbrake. It’s been one of our most popular articles, and many customers have thanked us for helping them discover features and benefits they didn’t realize Airbrake could provide.

As a follow up to our TLS deprecation post last August we wanted to remind all Airbrake customers that we will be deprecating support for TLS protocols v1.0 and v1.1 as well as some insecure ciphers on June 30 2018.

Python 3

If you’ve already upgraded your application to Python 3 you can leverage our new Python notifier pybrake to provide more robust error reporting.

Making our way through our in-depth Node.js Error Handling series, today we’ll be diving into the ERR_CONSOLE_WRITABLE_STREAM error, which is one of the many System Errors Node produces. Node throws System Errors when an exception occurs within the application’s runtime environment and such errors typically indicate that there was an operational problem within the program. An ERR_CONSOLE_WRITABLE_STREAM error indicates that an attempt was made to create a new Console API class without passing a valid stdout stream in which to place any generated output.

The 408 Request Timeout is an HTTP response status code indicating that the server did not receive a complete request from the client within the server’s allotted timeout period. The 408 Request Timeout error code appears similar to the 504 Gateway Timeout error we explored in a previous article, which indicates that that a server acting as a gateway or proxy timed out. However, the 408 Request Timeout error isn’t a message from a gateway or proxy server somewhere in the node chain, but is a direct message from the active server the client has connected to (like a the web server)

Making our way through our in-depth Python Exception Handling series, today we’ll be getting into the UnboundLocalError. An UnboundLocalError is raised when a local variable is referenced before it has been assigned. This error is a subclass of the Python NameError we explored in another recent article.

Regression testing is a form of software testing that confirms or denies a software’s functionality after the software undergoes changes. The term regression actually means “the act of reverting back to a previous state.” By extrapolating that definition into the realm of software development we can infer that regression testing is performed to verify that software has not unintentionally regressed to a previous state. Regression testing is ideally performed every time a software component or feature is modified, to help identify (and resolve) any newly discovered or regressed issues.

There are many possible errors in Node.js, so today we’ll continue our detailed Node.js Error Handling series by looking at one of the assorted System Errors Node produces, ERR_BUFFER_TOO_LARGE. Node throws a System Error when an exception occurs within the program’s runtime environment, and such errors are typically an indication that there was an operational problem within the application. An ERR_BUFFER_TOO_LARGE error indicates that an attempt was made to instantiate or allocate a Buffer object of a size exceeding the current maximum (typically 2,147,483,647, or the maximum size of a 32-bit signed binary integer).

The 407 Proxy Authentication Required is an HTTP response status code indicating that the server is unable to complete the request because the client lacks proper authentication credentials for a proxy server that is intercepting the request between the client and server. The 407 error code is similar to the 401 Unauthorized error we looked at a few months ago, which indicates that the client could not be authenticated with the server. However, in the case of a 407 Proxy Authentication Required error, the server isn’t reporting a direct authentication issue, but is instead reporting that the client needs to authenticate with a proxy server, which must send a special Proxy-Authenticate header as part of the response.

Our journey continues through our detailed Python Exception Handling series with a deep look at the NameError found in Python. Just as with many other programming languages, Python source code (typically found in .py files) is initially compiled into bytecode, which is a low level representation of source code that can be executed by a virtual machine via the CPython interpreter. Part of this process involves loading local or global objects into the callstack. However, when Python attempts to load an object that doesn’t exist elsewhere in the callstack it will forcefully raise a NameError indicating as much.

Node.js contains a plethora of possible errors it can throw during execution, so today we’ll continue our in-depth Node.js Error Handling series by looking at one of the many System Errors Node produces: the ERR_BUFFER_OUT_OF_BOUNDS. Node throws a System Error when an exception occurs within the program’s runtime environment, and such errors are typically an indication that there was an operational problem within the application. An ERR_BUFFER_OUT_OF_BOUNDS error indicates that an operation was made outside the bounds of a Buffer object.

Next up, in our deep dive into Java Exception Handling, today we’ll be digging into the IncompatibleClassChangeError. This error is a base exception class for a variety of errors thrown when the Java Virtual Machine (JVM) recognizes an incompatibility between two compiled class definitions that are executing in tandem. In child class, which we just looked at last week, is the AbstractMethodError, which extends the IncompatibleClassChangeError and is thrown when abstract method incompatibilities are detected between two classes.

Continuing along through our in-depth Python Exception Handling series, today we’ll dig into Python’s MemoryError. As with all programming languages, Python includes a fallback exception for when the interpreter completely runs out of memory and must abort current execution. In these (hopefully rare) instances, Python raises a MemoryError, giving the script a chance to catch itself and break out of the current memory draught and recover. However, since Python uses the C language’s malloc() function for its memory management architecture, it is not guaranteed that all processes will be able to recover – in some cases, a MemoryError will result in an unrecoverable crash.

Application performance management (APM) is the practice of monitoring and managing the performance, availability, and capability of modern software applications. APM doesn’t have an explicit, dictionary definition, but is rather an industry-created term that encompasses nearly everything to do with monitoring and managing code, application performance, transaction times, and end user experience.

The number of possible Node.js errors is extensive, so today we continue our detailed Node.js Error Handling series by looking at one of the many System Errors-categorized errors called ERR_ASYNC_TYPE. Node throws a System Error when an exception occurs within the program’s runtime environment, and such errors are typically an indication that there was an operational problem within the application. An ERR_ASYNC_TYPE error indicates that an attempt was made to pass an invalid data type to the AsyncResource class constructor.

Moving along through our in-depth Java Exception Handling series, today we’ll be going over the AbstractMethodError. This error is thrown when there are incompatibilities between compiled classes/JAR files using abstract methods.

Today, as we make our way through our detailed Python Exception Handling series, we’ll be looking into the KeyError , which is the close sibling of the IndexError we looked at last week. Whereas the IndexError is raised when trying to access an invalid index within a list, the KeyError is raised when accessing an invalid key within a dict.

DevOps has emerged in recent years as a direct attempt to counteract the typical problem of slow software releases. Every day that passes between the inception of a great software idea and its eventual release into the wild is another day in which that idea loses relevance and value to users. In business, the concept the first-mover advantage sums this up nicely: The first occupant of a market segment is provided a significant advantage over the rest of the competition. Even if the software your organization is developing doesn’t have any competitors, there are still major incentives (financial and otherwise) to releasing in a timely manner.

Next up in our deep Node.js Error Handling series we’ll be tackling the ERR_ASYNC_CALLBACK error type, which falls into the broader System Errors category of Node. Node throws a System Error when an exception occurs within the program’s runtime environment, and such errors are typically an indication that there was an operational problem within the application. An ERR_ASYNC_CALLBACK error indicates that an attempt was made to register a non-function data type as an async_hooks constructor callback.

Moving right along through our in-depth Python Exception Handling series, today we’ll be going over the IndexError , in all its glory. The IndexError is one of the more basic and common exceptions found in Python, as it is raised whenever attempting to access an index that is outside the bounds of a list.

A 308 Permanent Redirect message is an HTTP response status code indicating that the requested resource has been permanently moved to another URI, as indicated by the special Location header returned within the response. The 308 Permanent Redirect code was added to the HTTP standard relatively recently in April 2015, as detailed in the RFC7538 specification document for the 308 status code. As written in the RFC specification, the 308 Permanent Redirect code was necessary to fill in the gap left with similar codes of 301, 302, and 307.

Our journey continues through our in-depth Java Exception Handling series as, today, we dig into the depths of the NoSuchElementException. As the name suggests, a NoSuchElementException is thrown when trying to access an invalid element using a few built-in methods from the Enumeration and Iterator classes.

DevOps is the practice of combining the philosophies and tools of software development (Dev) and software operation (Ops). For better or worse, DevOps encompasses every aspect of a software system, including actual source code, infrastructure, configuration, data, testing, deployment, staging, production, and so forth. Thus, finding and implementing the most widely accepted DevOps best practices can be a challenge, as there’s no absolutely “correct” technique. Instead, improving your teams' DevOps practices is just as much about executing a philosophical shift as it is altering code or scripts in the system.

Making our way through our in-depth Node.js Error Handling series, today we’ll be going over the first of the various System Errors that can be thrown in Node, ERR_ARG_NOT_ITERABLE. Node throws a System Error when an exception occurs within the program’s runtime environment and are typically an indication that there was an operational problem within the application. In the case of the ERR_ARG_NOT_ITERABLE error, the its appearance indicates that a Node.js API method or function expected an iterable argument, but the actual value passed was not an iterable.

Making our way through our detailed Python Exception Handling series we arrive at the ImportError , along with its single child subclass of ModuleNotFoundError. The ImportError is raised when an import statement has trouble successfully importing the specified module. Typically, such a problem is due to an invalid or incorrect path, which will raise a ModuleNotFoundError in Python 3.6 and newer versions.

In Part 1 of this series we setup our development environment, created our twitter-bot project, integrated it with the Twitter API so it could send out programmatic tweets, and performed a basic Atom feed retrieval for some actual content to tweet. In Part 2 we integrated Airbrake’s Node.js software to handle automatic error reporting, plus, we also started the AWS Lambda integration.

Moving along through our detailed Java Exception Handling series, today we’ll be going over the InterruptedException. An InterruptedException is thrown when a thread that is sleeping, waiting, or is occupied is interrupted.

Moving along through our detailed Node.js Error Handling series, today we’ll be exploring the TypeError. Within the Node framework a TypeError indicates that a passed argument is not of the appropriate type. This method is used liberally throughout the built-in Node API modules, and should also be used within your own custom code to perform type checking at the top of of your functions and methods.

Over the next week we’ll be learning how to create a fully-automated, NodeJS, serverless Twitter bot with real-time error monitoring capabilities via Airbrake. Our Twitter bot will be capable of performing just about any task you can imagine, and it will do so serverlessly, by making use of the power of AWS Lambda functions. Let’s get right into it!

The 410 Gone Error is an HTTP response status code indicating that the resource requested by the client has been permanently deleted, and that the client should not expect an alternative redirection or forwarding address. The 410 Gone code may appear similar to the 404 Not Found code that we looked at few months ago, but the two codes serve a distinctly different purpose. A 404 code indicates that the requested resource is not currently available, but it could be available in future requests. Conversely, a 410 code is an explicit indication that the requested resource used to exist, but it has since been permanently removed and will not be available in the future. Thus, a 404 response code indicates that the user agent (browser) can repeat requests to the same resource URI, while a 410 tells the user agent not to repeat requests to that same resource.

Moving along through our in-depth Python Exception Handling series, today we’ll be going over the EOFError. The EOFError is raised by Python in a handful of specific scenarios: When the input() function is interrupted in both Python 2.7 and Python 3.6+, or when input() reaches the end of a file unexpectedly in Python 2.7.

Preventing software bugs can be a tricky business. Bugs can occur as a result of all sorts of problems, from improper testing or messy code to lack of communication or inadequate specifications documents. In this article we’ll explore the three main categories of software bug, along with the various causes of each, and how implementing a few simple techniques can help you and your team prevent such software bugs in your own projects. Let’s take a look!

Making our way through our in-depth Java Exception Handling series, today we’ll be going over the SocketException. As the name suggests, a SocketException occurs when a problem occurs while trying to create or access a Socket.

Making our way through the twists and turns of our full Node.js Error Handling series, today we’ll be checking out the SyntaxError in Node. As with nearly every other programming language on the market, a Node SyntaxError indicates that a code statement could not be correctly parsed, which means that the executor has no way of determining the intent behind the code. This usually happens as a result of typos, but the actual error messages associated with SyntaxErrors can be fairly vague and not all that useful.

A 307 Temporary Redirect message is an HTTP response status code indicating that the requested resource has been temporarily moved to another URI, as indicated by the special Location header returned within the response. The 307 Temporary Redirect code was added to the HTTP standard in HTTP 1.1, as detailed in the RFC2616 specification document that establishes the standards for that version of HTTP. As indicated in the RFC, “since the redirection may be altered on occasion, the client should continue to use the Request-URI for future requests.”

Moving along through our in-depth Python Exception Handling series, today we’ll be going over the SyntaxError. As with (probably?) every other programming language ever created, a SyntaxError is an indication that there is a syntactic error in the code, which causes the parser or compiler or executor to be unable to determine what the intention of the code is. In the case of some programming languages a SyntaxError is a compiler error and not considered a runtime error, which can be caught by in-code execution. In the case of Python, a SyntaxError can be either a runtime or a compiler error, depending on the scenario and the code that generated it.

Managing software teams can be difficult, even for the most disciplined and well-established organizations. Every aspect of the software development process must be carefully considered and balanced, allowing multiple teams to equally and efficiently produce software that customers will truly love. Managing these teams requires an understanding of the details of the project, along with the broader picture of relationships within and among teams, as well as the business requirements behind each executive decision.

Moving along through the in-depth Java Exception Handling series we’ve been going through, we next arrive at the MalformedURLException. A MalformedURLException is thrown when the built-in URL class encounters an invalid URL; specifically, when the protocol that is provided is missing or invalid.

Moving along through our detailed Node.js Error Handling series, in today’s article we’ll be checking out the ReferenceError in all its glory. If you’re familiar with plain JavaScript ReferenceErrors, the ReferenceError class in Node will look quite familiar, since it performs the same role: When a reference is made to an object that hasn’t been defined in previously executed statements, a ReferenceError is thrown.

A 303 See Other message is an HTTP response status code indicating that the requested resource can be found at another URI (address) by using the GET HTTP method. The 303 See Other code is typically provided in response to a POST, PUT, or DELETE HTTP method request, which indicates to the client that the server successfully received the data associated with the request, and the client should send a new GET request to the new URI it was provided by the server.

Making our way through our detailed Python Exception Handling series, next up on the docket is the BufferError. The BufferError occurs when a problem arises while working with any sort of memory buffer within Python. Specifically, classes like memoryview and BytesIO tend to raise these error types when something goes wrong.

Deployment isn’t usually the sexiest stage of application development, but performing it properly and efficiently is one of the most important factors in producing stable, successful software. To simplify this process, numerous deployment tools have recently emerged that can handle everything from automatically building and testing code to instantly deploying it and reporting errors back to the team when they occur. However, determining what tools are the best can be a bit challenging, especially if you or your team haven’t been keeping up on the latest “continuous XYZ” trends.

Making our way through our detailed Java Exception Handling series we arrive at the AssertionError that we’ll be going over today. As with many other languages, the AssertionError in Java is thrown when an assert statement fails (i.e. the result is false).

Continuing along through our in-depth Node.js Error Handling series, today we’ll be going over the RangeError. As with many other programming languages, including Ruby with the RangeError article we covered in that language, the Node.js RangeError is thrown to indicate that a passed function argument does not fall within the valid set or range of acceptable values. This might be because the value simply falls outside a given numeric range, or because there is a specific set of allowed values and the passed argument is not one of them.

A 304 Not Modified message is an HTTP response status code indicating that the requested resource has not been modified since the previous transmission, so there is no need to retransmit the requested resource to the client. In effect, a 304 Not Modified response code acts as an implicit redirection to a cached version of the requested resource.

Moving along through our in-depth Python Exception Handling series, today we’ll dig into the AttributeError. The AttributeError in Python is raised when an invalid attribute reference is made, or when an attribute assignment fails. While most objects support attributes, those that do not will merely raise a TypeError when an attribute access attempt is made.

We all make mistakes. Such a mistake might be forgetting to turn the lights off before leaving the house, or unintentionally cutting off another driver on the way to work. Or, as a software developer, it might be accidentally introducing a defect into the newest software project the team is working on. While defects are inevitable during development, they can largely be identified, fixed, or prevented entirely long before they reach a production environment. Throughout this article we’ll explore a few tips for reducing production defects, which will boost overall software quality, reduce regressive issues, improve inter-team communication, and increase customer satisfaction. Let’s take a look!

Continuing along through our in-depth Java Exception Handling series, today we’ll be looking into the NotSerializableException. The NotSerializableException is thrown when attempting to serialize or deserialize an object that does not implement the java.io.Serializable interface.

Starting off into our detailed Node.js Error Handling series, today we’ll be going over the AssertionError. As with many other programming languages, Node.js comes with an assert class as part of its core modules set, allowing simple assertion tests to be performed. When such an assertion fails an AssertionError is thrown to indicate what went wrong.

Making our way through our detailed Python Exception Handling series, today we’re going over the AssertionError. Like many programming languages, Python includes a built-in assert statement that allows you to create simple debug message outputs based on simple logical assertions. When such an assert statement fails (i.e. returns a False-y value), an AssertionError is raised.

Many organizations are looking at ways to scale Agile implementations, but doing so can be a particularly challenging for businesses not well-versed in Agile practices. Properly scaling more traditional Agile frameworks can be difficult for organizations with excessive personnel or an abundance of individual teams working on one or more products simultaneously.

Moving along through our detailed Java Exception Handling series we come to the SSLHandshakeException. The SSLHandshakeException is thrown when an error occurs while a client and server connection fails to agree on their desired security level. This exception is one of a handful of classes that inherits from the parent SSLException class.

The Node.js error class hierarchy consists of about half a dozen unique classes, most of which inherit from the baseline Error class. A Node.js application will typically experience errors that fall into one of four categories:

A 301 Moved Permanently is an HTTP response status code indicating that the requested resource has been permanently moved to a new URL provided by the Location response header. The 3xx category of response codes are used to indicate redirection messages to the client, such that the client will become aware that a redirection to a different resource or URL should take place.

Moving along through our in-depth Python Exception Handling series, today we’ll be looking at the ZeroDivisionError. As you may suspect, the ZeroDivisionError in Python indicates that the second argument used in a division (or modulo) operation was zero.

I’m happy to announce that we’ve added code hunks support to Airbrake. Code hunks are lines of code surrounding each backtrace frame.

DevOps is the practice of combining the philosophies and tools of software development (Dev) and software operation (Ops). The term was first introduced during the 2008 Agile Toronto conference by developers and technologists Patrick Debois and Andrew Shafer. Yet, as with many relatively new technological terms thrown around the industry, it can be difficult to pin down exactly what DevOps is and how its functions are commonly put into practice.

Making our way through our in-depth Java Exception Handling series, today we’ll be going over the SocketTimeoutException. As you may suspect based on the name, the SocketTimeoutException is thrown when a timeout occurs during a read or acceptance message within a socket connection.

We finish up the current run of our detailed .NET Exception Handling series with a dive into the System.Deployment.Application.DeploymentException. The DeploymentException is actually a larger parent class to all exceptions that occur during deployment. For example, using the common ClickOnce method of application deployment might run into some issues, and the exception(s) thrown during this process are all derived from DeploymentException.

Making our way through our detailed Python Exception Handling series brings us today to the OverflowError within Python. Just like most other programming languages, the OverflowError in Python indicates that an arithmetic operation has exceeded the limits of the current Python runtime. This is typically due to excessively large Float values, as Integer values that are too big will opt to raise MemoryErrors instead.

Dozens of development methodologies have popped up over the relatively few decades in which modern software development has taken place. Each method provides its own benefits and challenges throughout the software development life cycle, but it can be particularly difficult to determine how your software methodology affects production behavior of your application.

Making our way through our detailed Java Exception Handling series, today we’ll dive into the UnsupportedOperationException. The UnsupportedOperationException is used by a number of built-in Java methods to indicate that the method in question is not currently implemented. This is functionally similar to exceptions found in other languages, such as the .NET NotImplementedException we explored in a previous article.

Winding down our in-depth .NET Exception Handling series, today we’re taking a look at the System.ComponentModel.LicenseException. When creating proprietary applications and .NET components intended to be licensed, you may wish to implement some form of licensing using the built-in LicenseProvider class, which makes it relatively easy to add licensed content to your application. If your application is executed and no valid license is detected a LicenseException is thrown to prompt an indication to the user or developer that licensing must be satisfied.

Today we get started with our in-depth Python Exception Handling series by looking at the FloatingPointError. As with most programming languages, the FloatingPointError in Python indicates that something has gone wrong with a floating point calculation. However, unlike most other languages, Python will not raise a FloatingPointError by default. The ability to do so must be implemented by including the fpectl module when building your local Python environment.

Managing budgets and other important accounting practices for software development projects can be tricky. Many of the standards and practices that have been used for decades are rapidly becoming severely outdated and obsolete, so it can be challenging to properly plan your department’s production monitoring budget, along with the other critical components necessary to produce a successful application; one that remains healthy well after it’s in the hands of your customers or clients.

Moving along through our in-depth Java Exception Handling series, today we’ll get into the IllegalMonitorStateException. The IllegalMonitorStateException is thrown when a thread has been instructed to wait for an object’s monitor that the specified thread does not have ownership of.

Fast approaching the conclusion of our current .NET Exception Handling series, today we’ll be looking into the System.Data.SqlTypes.SqlTypeException. The appearance of an SqlTypeException is the result of something going wrong while using the System.Data.SqlTypes namespace classes.

The Python exception class hierarchy consists of a few dozen different exceptions spread across a handful of important base class types. As with most programming languages, errors occur within a Python application when something unexpected goes wrong. Anything from improper arithmetic and running out of memory to invalid file references and unicode formatting errors may be raised by Python under certain circumstances.

Throughout an entire software development life cycle, it is all too common for security practices to be neglected in favor of the more tangible, immediate benefits of adding that next cool application feature or landing another large swath of users. However, as we’ve witnessed with the many massive data breaches in recent years, scaling up your information security through proper security testing and analysis has never been more crucial to maintain a healthy business and reputable brand.

Making our way through our detailed Java Exception Handling series, today we’ll tackle the EOFException. Most developers will probably recognize that the acronym EOF in this exception name usually stands for “end of file”, which is exactly the case here. When an EOFException is thrown in Java, this indicates that the end of the file or stream has been reached unexpectedly.

As we approach the end of our in-depth .NET Exception Handling series, today we’ll be taking a closer look at the System.ComponentModel.InvalidAsynchronousStateException. An InvalidAsynchronousStateException is a complex exception that occurs when an operation is attempted for which its target thread no longer exists, or has no message loop.

Moving along through the detailed Java Exception Handling series we’ve been working on, today we’ll be going over the IndexOutOfBoundsException. The IndexOutOfBoundsException is thrown when attempting to access an invalid index within a collection, such as an array, vector, string, and so forth. It can also be implemented within custom classes to indicate invalid access was attempted for a collection.

After months (or even years) of blood, sweat, and tears, you and your team have finally launched your latest application into production and are basking in the glow of a job well done. And yet, there’s that tiny itch in the back of your minds, nervously waiting and wondering if the other shoe will drop. Nothing seems terribly wrong for some time, as hours turn to days, which eventually turn to weeks without any major issues. Sure, production errors crop up from time to time, but nothing too impactful.

As we approach the end of our detailed PHP Exception Handling series, today we’ll take a closer look at the IntlException. The IntlException is thrown by the wide variety of classes, functions, and methods found within the Internationalization Functions API set. These functions are are a PHP-based wrapper for the International Components for Unicode (ICU) library set, allowing code to easily work with strings, numbers, and dates across a variety of locales and formats.

Moving along through the detailed .NET Exception Handling series, today we will be exploring the EntityException. The EntityException is the base exception class used by the EntityClient provider, which is part of the overall Entity Framework, which enables model-to-object mapping and relationships throughout ADO-based applications.

Making our way through our comprehensive Java Exception Handling article series, today we’ll be looking into the NoSuchMethodError. As you may suspect based solely on the name, the NoSuchMethodError is thrown when a class can no longer locate the method definition of the specified method. While this error is typically caught by the compiler, it’s possible to find yourself in scenarios where it can occur during runtime, such as when a class was modified without other dependant classes being updated.

The Runtime Broker application is a Microsoft program included with Windows 8 (and newer versions) that handles permissions for all local Universal Windows Platform (UWP) applications. Normally, the Runtime Broker application is completely harmless and can be left alone to do its thing. However, in some rare instances you may be experiencing slowdown on your computer, only to find that RuntimeBroker.exe is using an abundance of memory and/or an excess of CPU time.

Traversing the depths of our detailed PHP Exception Handling series, today we’ll dive into the UnexpectedValueException. Not to be confused with the InvalidArgumentException that we covered in a previous article, the UnexpectedValueException is typically thrown when a value is not within an expected set of values. For example, if a function is returning a date value, but the runtime execution of this function produces a malformed date, you may opt to throw an UnexpectedValueException, so further execution using this value isn’t corrupted by it.

Moving along through our in-depth .NET Exception Handling series, today we’ll be going over the System.Web.HttpException. The HttpException is the most basic type of web-based exception, so it can be used for many general purposes that relate to something going wrong when processing an HTTP request in an ASP.NET or similar application.

Moving along through our in-depth Java Exception Handling series, today we’ll dive into the ExceptionInInitializerError , which is thrown when an error occurs within the static initializer of a class or object. Since an ExceptionInInitializerError isn’t ever the cause of a thrown error, catching such an exception provides an underlying causal exception that indicates what the actual source of the issue was.

Making our way through our in-depth PHP Exception Handling series, today we’ll be going over the UnderflowException. If you’re familiar with computer-based arithmetic rules, you’ll likely be able to deduce that the UnderflowException is intended when performing arithmetic using decimal numbers that result in an inaccurate value, because the PHP engine cannot represent the proper scale of the actual, absolute value.

Making our way through our detailed .NET Exception Handling series, today we’ll be taking a closer look at the System.Web.HttpParseException. An HttpParseException should be thrown when something goes wrong while attempting to parse an HTML page.

Making our way through our detailed Java Exception Handling series, today we’ll be going over the OutOfMemoryError , which is thrown when the Java Virtual Machine (JVM) is unable to allocate an object due to a lack of memory.

Today we’ll take a look at the template method design pattern , which is the final design pattern introduced in the well-known book 1994, Design Patterns: Elements of Reusable Object-Oriented Software. We’ve covered all other patterns thus far in our detailed Guide to Software Design Patterns series, with both real world and fully functional C# code samples of each, illustrating how the patterns can be used and implemented in your own code.

Moving along through our detailed PHP Exception Handling series, today we’ll be going over the RangeException. The RangeException is similar to the DomainException, which we covered previously. In essence, the DomainException is used when input values (such as method arguments) are invalid and don’t fit the context or domain of the current code. On the other hand, RangeExceptions are ideal when output values are invalid, or otherwise don’t make sense.

Making our way through our detailed .NET Exception Handling series, today we’ll dive into the System.ServiceModel.EndpointNotFoundException. The EndpointNotFoundException is thrown when something goes awry while trying to connect to a Windows Communication Foundation (WCF) service-oriented application.

Moving along through our in-depth Java Exception Handling series, in today’s article we’ll be looking over the UnsatisfiedLinkError , which is thrown when attempting to dynamically load a native library that cannot be located by the Java Runtime Environment (JVM).

There are many indicators that your models have grown too big, but the most indicative is when your model breaks the single responsibility principle. First introduced by software engineer and author Robert Cecil Martin in his book Agile Software Development, Principles, Patterns, and Practices, the single responsibility principle states that every class in an application should have responsibility over one, and only one aspect of the overall software. Martin defines “responsibility” as a “reason to change,” indicating that each class should only ever have one reason to change.

Moving along through our in-depth PHP Exception Handling series, today we’ll be going over the PDOException. PHP Data Objects (or PDO) are a collection of APIs and interfaces that attempt to streamline and consolidate the various ways databases can be accessed and manipulated into a singular package. Thus, the PDOException is thrown anytime something goes wrong while using the PDO class, or related extensions.

As we approach the end of our thorough Guide to Software Design Patterns series we’ll be looking into the state design pattern. The state pattern allows you to programmatically change the behavior of a class based on changes made to the underlying state of said class. In this article we’ll look at both a real world example and a fully-functional C# code sample of the state design pattern, so let’s get to it!

Moving along through the detailed .NET Exception Handling series, today we will be exploring the System.Management.ManagementException. A ManagementException is thrown when something goes wrong while working with the Windows Management Instrumentation (WMI) components contained within the System.Management namespace. WMI essentially allows scripts and applications to perform queries against local or remote systems, devices, and even other apps. These queries can retrieve a variety of information, including logical disk data, CPU utilization, database connectivity, and so forth.

Introduced in ES6, promises are the big leap forward into asynchronous operations that JavaScript has needed for some time. However, in ES7 (or ESNext, as the upcoming release is sometimes referred to), promises were dramatically improved with the introduction of async functions and the await operator. In short, an async function simply defines and returns an asynchronous function, while the await operator is used to wait for a Promise object.

We’re proud to announce a new library to make it easier to use airbrake with Python. Airbrake Python Integrations is now the home for integrations built on top of our core Python notifier library. This initial release includes integrations for three major Python projects: Django, Flask, and Twisted. We’re excited to work with the community to improve and expand the library.

Making our way through our detailed Java Exception Handling series, today we’ll be going over the ClassCastException. Any attempt to cast (i.e. convert) an object to another class for which the original class isn’t a inherited from will result in a ClassCastException.

Moving along through our in-depth PHP Exception Handling series, today we’ll take a closer look at the OverflowException. Unlike most other languages, in PHP the OverflowException is not explicitly related to attempts to use memory space/addresses that are outside the bounds of the memory assigned to the application. Instead, the OverflowException in PHP is focused around a simple concept: Adding an element to a collection that is already full.

Next up in our comprehensive Java Exception Handling series we’ll be looking over the UnknownHostException. The UnknownHostException can be thrown in a variety of scenarios in which a remote connection fails due to an invalid or unknown host (i.e. IP, URL, URI, etc).

Making our way through the detailed .NET Exception Handling series we’ve been creating, today we’ll be looking into the System.Security.Authentication.InvalidCredentialException. The InvalidCredentialException occurs when authentication fails for one of a number of authentication stream classes in the .NET Framework.

Making our way through our detailed PHP Exception Handling series, today we come to the OutOfBoundsException. The OutOfBoundsException is not to be confused with the OutOfRangeException, which we covered a few weeks ago in our PHP Exception Handling - OutOfRangeException article. While OutOfRangeException is meant to be used at compile time, the OutOfBoundsException inherits directly from the RuntimeException and, thus, it is used for key-based errors that occur during runtime.

If you haven’t been keeping up with new developments in the world of, well, Java development, then you may have overlooked the ground-breaking release of the Kotlin language version 1.0 in early 2016. Kotlin rethinks many of the syntaxes, shortcomings, and limitations of Java and pushes the boundaries for Java and Android application development.

Moving along through our detailed Java Exception Handling series, today we’ll be taking a closer look at the UnsupportedClassVersionError. The UnsupportedClassVersionError can be rather confusing, but the simplest explanation is that it occurs when the Java Virtual Machine (JVM) attempts to access a class file that was compiled using a different Java version than is currently supported.

Next up in our in-depth Guide to Software Design Patterns series we’ll dig into the strategy design pattern. The strategy pattern is ideal when code should programmatically determine which algorithm, function, or method should be executed at runtime.

Continuing our journey through the in-depth .NET Exception Handling series, today we’ll go over the System.Xml.XPath.XPathException. A XPathException is thrown anytime an error occurs while performing basic XPath parsing, using classes such as XPathNavigator and the like.

Moving along through the encompassing PHP Exception Handling series we’ve been creating, today we’ll be taking a look at the PHP ReflectionException. A ReflectionException occurs when there’s an error while performing any sort of reflection; specifically when dealing with the Reflector, or with other classes that inherit from it.

Next up in our in-depth Java Exception Handling series we’ll take a closer look at the FileNotFoundException. As you probably can guess, the FileNotFoundException is thrown when calling a number of IO methods in which you’ve passed an invalid file path. We’ll look at where FileNotFoundException sits in the Java Exception Hierarchy, and also go over some functional code samples showing how this error might come about, so let’s get to it!

The latest version of the popular Chrome browser was officially released this week, and with it comes a handful of exciting new features for developers and technical managers alike. From out of the box ES6 module support and mobile device throttling to WebUSB API support and storage usage statistics, there are a bunch of new development tools in Chrome!

Making our way through our detailed .NET Exception Handling series, we next come to the RegexMatchTimeoutException. This exception is thrown when performing RegexMatchTimeoutException.Match() or RegexMatchTimeoutException.IsMatch() calls in which the specified timeout duration is exceeded while performing the regex operation. Let’s jump right in!

Next up in our detailed Guide to Software Design Patterns series we’ll look at the visitor design pattern , which is one of the more complex patterns we’ll be discussing. The visitor pattern is ideal for adding new capabilities to existing objects, without modifying the classes on which those objects operate.

Making our way through our detailed PHP Exception Handling series, today we’ll explore the PharException. Phar is shorthand for PHP Archive. A phar file is a convenient way to compress and store an entire PHP application in a single executable file. This functionality is similar to JAR files found within the Java ecosystem.

Today we make our way to the IllegalStateException in Java, as we continue our journey through Java Exception Handling series. The “proper” use of the IllegalStateException class is somewhat subjective, since the official documentation simply states that such an exception “signals that a method has been invoked at an illegal or inappropriate time. In other words, the Java environment or Java application is not in an appropriate state for the requested operation.”

Moving along through our in-depth .NET Exception Handling series, today we face off against the System.DivideByZeroException. The System.DivideByZeroException is thrown when attempting to divide an integer or a decimal by zero.

For most Rails developers, a massive benefit of using the Rails framework is the power of its core components, like the dominant Active Record. Acting as the model in the core model-view-controller paradigm that Rails is built around, according to the official documentation, an Active Record is the “layer of the system responsible for representing business data and logic. Active Record facilitates the creation and use of business objects whose data requires persistent storage to a database.” In other words, an Active Record model should represent a data layer component (typically a database table), and each instance of a particular model is a one-to-one representation of an object in the database. This relationship is typically known as Object Relational Mapping (or ORM).

Travelling along through the deep undergrowth, in the PHP Exception Handling forest we’ve created, today we come to the lush meadow that is the OutOfRangeException. In spite of what you might suspect based on the name, the OutOfRangeException is not thrown when attempting to access an index outside the bounds of an array or other collection object. Instead, an OutOfRangeException is meant to be used for compile time issues, such as trying to access an object that doesn’t make logical sense in the context.

Today we’ll continue our journey through the Guide to Software Design Patterns series with a deep dive into the observer design pattern. The observer pattern is categorized as a behavioral design pattern, and its primary purpose is to allow a observer to “subscribe” to push-notifications generated by a provider.

Making our way through our in-depth Java Exception Handling series, today we’ll dig into the Java StackOverflowError. As with most programming languages, the StackOverflowError in Java occurs when the application performs excessively deep recursion. However, what exactly qualifies as “excessively deep” depends on many factors.

Making our way through our detailed .NET Exception Handling series, today we’ll tackle the lovely System.Data.ObjectNotFoundException. The System.Data.ObjectNotFoundException is typically used and thrown when dealing with ADO.NET (or other data layer components) and an expected object cannot be found.

Making our way through our in-depth PHP Exception Handling series, on this fine day we’ll be going over the LengthException in PHP. LengthException is not a complex beast by any stretch of the imagination. Instead, it’s merely meant to be thrown when a value length should be considered invalid.

Moving along through our detailed Java Exception Handling series, today we’ll dive into the ConnectException in Java. As you can probably guess, the ConnectException indicates an error has occurred while attempting to connect a socket to a remote address, such as when trying to access a URL that doesn’t exist, or which refuses outside connections.

Moving along through our detailed Guide to Software Design Patterns series, today we land on the island of the memento design pattern. The memento pattern is typically used to store the historical state of an object and, therefore, allow previous states to be restored at any time. The pattern shares many similarities with the command pattern, which we explored in our previous Behavioral Design Patterns: Command Design Pattern post.

Taking the next step in our journey through the vast .NET Exception Handling series, today we’re taking a closer look at the System.Xml.XmlException class. As you might suspect from the name, the System.Xml.XmlException is the generic error that is thrown when most XML-related errors occur, such as failure to parse malformed XML content.

Making our way through our in-depth PHP Exception Handling series, today we’ll go over the InvalidArgumentException in PHP. The InvalidArgumentException should be thrown when an inappropriate argument is passed to a method or function. This can be either due to the actual object data type, or because the data itself is invalid in some way.

TLS 1.0 and 1.1 deprecation

As part of our commitment to maintain a trusted platform and promote the safety of your data we have begun the process of deprecating TLS 1.0 and 1.1.

Although total solar eclipses typically occur at least twice a year in some part of the world, on August 21st, 2017, many Americans will experience the first total eclipse in their lifetimes! Last time anyone on U.S. soil saw a total eclipse was in the lovely state of Hawaii back in 1991. Prior to that, a few states near the west coast got a glimpse in 1979, but this 2017 event will mark a total eclipse path across the entire country!

Making our way through our in-depth Java Exception Handling series, today we’re taking a look at the java.lang.NumberFormatException. As you may suspect, the NumberFormatException is thrown when code attempts to convert an invalid String into one of the other generic numeric wrapper classes, such as Integer, Byte, Long, and so forth.

Moving along through our detailed .NET Exception Handling series, today we’ll be tackling the ever-popular System.OverflowException. With a name that most developers will probably recognize, the System.OverflowException in .NET indicates that an invalid arithmetic, casting, or conversion error occurred within a checked context.

Rails is a powerful and relatively easy to use framework. Its dominant principles heavily emphasize convention over configuration, allowing new Rails applications to be up and running in a fraction of the time for applications created in many other, more verbose languages. However, the simplicity that Rails provides can also be a pitfall, particularly for newer developers just getting into the design space. In this article we’ll examine a handful of some of the most common mistakes in Rails development, and provide guidance on how these can best be avoided in your own coding adventures, so let’s get to it!

High volume warnings trigger re-notifications based on an error’s occurrence count. When enabled, re-notifications will be triggered when an error’s occurrences reach 10k, 100k, 200k, 300k and every 100,000 occurrences thereafter.

Next up in our in-depth PHP Exception Handling series we’ll be looking into the domain of the, well, DomainException. The specific scenarios in with a DomainException should be used are varied and somewhat debated, but the current best practice is to throw a DomainException when a value doesn’t adhere to the valid “data domain” of the given context.

Making our way through the detailed Guide to Software Design Patterns series we’ve been publishing, today we’ll be exploring the handy mediator design pattern. In the mediator design pattern, a mediator object encapsulates how other types of objects interact, without the need for those objects to be aware the implementation of other objects.

Today we continue our detailed Java Exception Handling series with a closer look at the java.lang.ClassNotFoundException. Unlike many Java errors that can occur in a variety of scenarios, the ClassNotFoundException can only be thrown as a result of three different method calls, all of which handling loading classes by name.

Moving along through our detailed PHP Exception Handling series, today we’ll take a closer look at the BadMethodCallException in PHP, along with its lesser-used parent BadFunctionCallException. The primary scenario in which a BadMethodCallException is thrown is when calling either an instance or static method that doesn’t exist, or expects a different argument signature than the one provided.

C# 7.0, the latest major version of the extremely popular programming language, was released in March 2017 alongside Visual Studio 2017, bringing a number of new features and capabilities to the table. Today we’ll continue our deep dive into some of these awesome features in our ongoing series, What’s New in C# 7.0?:

Today, on our continued journey through the in-depth .NET Exception Handling series, we’ll be taking a closer look at the System.IO.PathTooLongException in .NET. As the name implies, the System.IO.PathTooLongException is usually thrown when a path is passed to a variety of System.IO namespaced methods that is too long for the current .NET version and/or operating system configuration.

Today we’ll be exploring the Iterator design pattern in our ongoing Guide to Software Design Patterns series. The iterator design pattern may be the most frequently used pattern we’ll be looking at throughout this entire collection of articles. The purpose of this pattern is to traverse through a collection of objects and retrieve each element in turn. This practice is used in programming so often that many developers may not even realize it’s considered a design pattern at all!

Moving along through our detailed PHP Exception Handling series, today we’ll dive into the PHP ErrorException class. In the most basic sense, the PHP ErrorException is meant to be explicitly thrown when you want to catch and handle errors that would otherwise be ignored, such as Notices or Warnings.

Moving along through our in-depth .NET Exception Handling series, today we’ll dig deeper into the System.Activities.ValidationException. The System.Activities.ValidationException is meant to be thrown when a Windows Workflow Foundation element, such as an Activity or Workflow, is in an invalid state.

Moving right along through our in-depth Java Exception Handling series, today we’ll be digging into java.lang.IllegalArgumentException. The IllegalArgumentException is intended to be used anytime a method is called with any argument(s) that is improper, for whatever reason.

Thanks to frequent updates and continuous support, C# remains one of the most popular modern development languages. The latest major version, released in March of 2017 and coinciding with the release of Visual Studio 2017, brings with it a number of new features, which we’ve been covering in our ongoing series, What’s New in C# 7.0?. Thus far we’ve investigated a number of topics:

Next up in our in-depth PHP Exception Handling series, today we’re digging into the PHP DOMException error. There are a variety of reasons a DOMException can occur, but all of them are related to using the Document Object Model namespace and its powerful functionality.

Not to be rude, but I hereby command you to check out today’s article in our ongoing Guide to Software Design Patterns series, in which we dive into the extremely useful command design pattern in all its glory! As another behavioral pattern, the command design pattern makes it easy to add work to a queue, which can be processed by a client at any moment in time. Furthermore, the client need not be aware of the underlying functionality or implementation of the queued work.

Making our way through our detailed .NET Exception Handling series, today we’ll dig into the fun System.Threading.ThreadAbortException. A System.Threading.ThreadAbortException is thrown when the Abort() method is invoked on a Thread instance.

Today we’ll take another journey through the “Land of Errors” of our ongoing Java Exception Handling series, with a deep dive into the java.lang.ArrayIndexOutOfBoundsException. As the name clearly indicates, the ArrayIndexOutOfBoundsException is thrown when an index is passed to an array which doesn’t contain an element at that particular index location.

Moving along in our detailed PHP Exception Handling series, today we’ll take a look at the PHP ClosedGeneratorException. A closed generator exception occurs when attempting to perform a traversal on a generator that has already been closed or terminated.

Monitoring your applications with Airbrake can be a game-changing decision. You’ll enhance your understanding of your users, your code, and even your dev team.

Luckily, you don’t need to be an advanced Airbraker to reap the benefits of this powerful tool. Let’s run through a few simple tips that can take your dev efforts to a new level.

C# 7.0, the latest major version of the exceptionally popular language, was released in March 2017 alongside Visual Studio 2017, bringing a number of new features and capabilities to the table. Today we’ll dive deeper into the pattern matching and local functions features in our ongoing series, What’s New in C# 7.0?:

Moving along through our in-depth .NET Exception Handling series, today we’ll take a closer look at the System.Data.Linq.DuplicateKeyException. The DuplicateKeyException is typically thrown when performing LINQ operations on an underlying database/data context, while attempting to insert or create a record with the same identifying key as another record.

Today we’ll begin the last leg of our journey through all the most common design patterns within our Guide to Software Design Patterns series. It’s finally time to move onto Behavioral patterns, which try to build a foundation on which objects can communicate and assign responsibilities to one another. First up in the Behavioral pattern list is the Chain of Responsibility design pattern, which makes it easy to chain objects together in an ordered set. A specific, logical requirement is passed into the chain and is checked against each object in the set, in order, until a suitable match is found that meets the needs of the particular requirement.

Moving along through our in-depth Java Exception Handling series, today we’ll take a closer look at the java.lang.reflect.InvocationTargetException. The java.lang.reflect.InvocationTargetException is thrown when working with the reflection API while attempting to invoke a method that throws an underlying exception itself.

Next up in our in-depth PHP Exception Handling series we’re taking a closer look at the PHP TypeError. TypeErrors are thrown in a few different scenarios where the PHP engine expects a particular object type, but a different type is provided instead.

Making our way through the detailed .NET Exception Handling series, today we’ll be tackling the System.Web.Services.Protocols.SoapException. The SoapException is only the second exception we’ve covered in this series that deals with the Windows Communication Foundation (WCF) framework, which is used to build service-oriented applications. The System.Web.Services.Protocols.SoapException is a rather fundamental error type, as it’s the basis of exceptions thrown by WCF apps when a client makes service calls via the SOAP protocol.

Today we’ll bite off another morsel from our delicious and mildly satiating Java Exception Handling series with a close look at the java.util.ConcurrentModificationException. The java.util.ConcurrentModificationException is typically thrown when code attempts to modify a data collection while that collection is actively in use, such as being iterated.

Today we’ll continue down the path of exploring all the cool new features that ES6 JavaScript brings to the table. Thus far in this series we’ve covered quite a bit of ground:

Next up in our in-depth PHP Exception Handling series we’re taking a closer look at the PHP ParseError. As you might suspect, a ParseError is thrown when PHP has trouble parsing a line of code. This could either be due to a typo or syntax error, or even while using the terrifying eval() function.

Today we’re looking at the last of the Structural design patterns within our comprehensive Guide to Software Design Patterns series. The proxy design pattern is intended to act as a simple wrapper for another object. The proxy object can be directly accessed by the user and can perform logic or configuration changes required by the underlying subject object, without giving the client direct access to said subject.

Moving along through our in-depth .NET Exception Handling series, today we come across the System.FormatException. As the name implies, the System.FormatException is thrown in a wide variety of scenarios, yet they all revolve around providing an improperly formatted argument to a vast array of methods and API calls.

Today we continue our adventure through the Java Exception Handling series with a close look at the java.lang.NoClassDefFoundError. In most cases, a java.lang.NoClassDefFoundError is thrown when a class reference was available during compile time, but has since disappeared (for whatever reason) during execution.

Today we’ll continue with our exploratory PHP Exception Handling series by diving deeper into the PHP AssertionError. As you can probably guess, an AssertionError is (sometimes) thrown when an assert() call fails. However, a number of default settings and configuration differences based on PHP versions means that AssertionErrors may not always behave as you expect them to.

Next up in our continued .NET Exception Handling series we come to the System.Collections.Generic.KeyNotFoundException. In most cases the System.Collections.Generic.KeyNotFoundException is thrown when attempting to access a Collection element using a key that doesn’t exist within said collection.

First released in early 2002, alongside the initial release of .NET 1.0, C# has had a lot of success in the development community. Thanks to continued support and frequent updates that coincide with each new release of Visual Studio, C# remains one of the most popular languages in use today. The latest major version, released in March of this year alongside Visual Studio 2017, brings with it a number of new features, so we thought it would be fun to explore what’s new in C# 7.0. Let’s get to it!

Today we start the journey through our Java Exception Handling series with a deep dive into the java.lang.NullPointerException. A java.lang.NullPointerException is thrown there’s an attempt to use null anywhere an object is actually required, such as trying to directly modify a null object.

Dive into the exciting world of the flyweight design pattern in today’s article, as we continue looking at Structural design patterns throughout our extensive Guide to Software Design Patterns series. The flyweight design pattern, named after the boxing weight class of the same name, is intended to be just as agile and adaptive as those nimble athletes. Flyweight gains this agility by minimizing memory and computational usage by sharing and reusing objects.

In today’s article we’ll continue our travels through the PHP Exception Handling series with a closer look at the DivisionByZeroError. As you might suspect, the DivisionByZeroError is (sometimes) thrown when attempting to divide a value by zero. The challenge is the caveat of “sometimes”, because this particular error might not be thrown as often as you think.

Moving right along through our .NET Exception Handling series, today we’ll take a closer look at the System.DllNotFoundException. As indicated by the name, a System.DllNotFoundException occurs when attempting to import a DLL that doesn’t exist.

All objects within the Java exception class hierarchy extend from the Throwable superclass. Only instances of Throwable (or an inherited subclass) are indirectly thrown by the Java Virtual Machine (JVM), or can be directly thrown via a throw statement. Additionally, only Throwables (or an inherited subclass) can be caught via a catch statement.

Today we begin our new PHP Exception Handling series with a deep dive into the ArithmeticError. As you can probably guess, the ArithmeticError is thrown when PHP code attempts to perform an invalid mathematical operation.

You can now get all the same Airbrake functionality of our desktop web app in that tiny computer you have in your pocket - your Airbrake error dashboard and web app are now fully optimized for mobile browsers. This means that all the error monitoring features you regularly use on your desktop browser are available to you wherever you have your smartphone.

Today, as we make our way through the last few Structural design patterns in our extensive Guide to Software Design Patterns series, we’ll be taking a closer look at the facade design pattern. The facade design pattern is one of the simpler (and thus most commonly used) patterns we’ll come across, as it provides a simple interface that can be used to manipulate more complex logic behind the scenes, hidden from the client executor.

In the past, understanding the PHP exception class hierarchy was easy, but the hierarchy included a somewhat serious flaw. In older PHP versions it often proved difficult, if not impossible, to handle fatal errors. In fact, most fatal errors typically caused the application to halt execution entirely. Now, thanks to changes introduced in PHP 7, exceptions are thrown (and can therefore be caught) when a fatal error occurs, allowing the application to continue functioning.

Many Americans celebrate the Fourth of July by hanging out with friends, having a backyard barbeque while enjoying some cool drinks and watching a wonderful display of colorful fireworks. In honor of the holiday, we thought we’d create our own little JavaScript fireworks display.

Next up in our journey through our .NET Exception Handling series, today we’ll take a gander at the System.Security.SecurityException. System.Security.SecurityExceptions occur when the caller – that is, the executing user account – doesn’t have proper permissions to access a particular resource.

Making our way through the .NET Exception Handling series, today we’ll be exploring the System.AccessViolationException in more detail. A System.AccessViolationException occurs when unmanaged/unsafe code attempts to use memory that has not been allocated, or to memory that it doesn’t have access to.

Today we finally come to the end of the journey through our Ruby Exception Handling series. The last, and perhaps most critical, error left to discuss is the Fatal Error, which indicates a severe crash in a Ruby application – something so dramatic that the process couldn’t recover from it through normal means.

Today, in our continued journey through the .NET Exception Handling series, we’ll be exploring the wide world of the System.ComponentModel.Win32Exception. As indicated by the Win32 part of the name, the System.ComponentModel.Win32Exception occurs only when dealing with legacy-style applications or code – where your application must invoke direct operating system calls, such as trying to execute other applications.

Today we continue our journey of exploring all the cool new features that ES6 JavaScript has to offer. Thus far in this series we’ve covered quite a bit of ground:

Moving right along through our JavaScript Error Handling series, today we’ll be tackling the Invalid Source Map Format JavaScript error. Although the Invalid Source Map Format error is technically a descendant of the base SyntaxError object, it applies to a very specific case; when using a deprecated symbol to indicate the URL for a source map, which allows for easier debugging of obfuscated code.

Next up in our continued journey through common Structural design patterns, as part of our extensive Guide to Software Design Patterns series, we’ll be exploring the decorator design pattern. The decorator pattern allows the behavior of an individual instance of an object to be changed without impacting the behavior of other instance objects of the same type.

Moving along through our JavaScript Error Handling series, today we’re going to closely examine the Malformed Formal Parameter error. Malformed Formal Parameter errors appear when attempting to use the Function() constructor to create your own function object, but then specifying invalid parameters when doing so.

Today, as we approach the end of our JavaScript Error Handling series, we’ll be looking at the Variable X Redeclares Argument TypeError a bit closer. Variable X Redeclares Argument TypeError is a strict mode only error that occurs when attempting to redeclare an argument (althought it’s technically a parameter in this context) within a function definition.

Moving along through our .NET Exception Handling series today we’re going to take a gander at the System.ServiceModel.FaultException. The System.ServiceModel.FaultException is the first error we’ve dealt with in this series that is tied directly to the Windows Communication Foundation (WCF) platform of services. These services act as a remote interface, such as an API, that can be accessed by clients and other applications to perform some actions, without the client knowing about the underlying logic of the service.

Today our journey through the Ruby Exception Handling series continues with one of the last remaining Ruby errors left to discuss: SystemStackError. This little baby pops up when code gets a little recursion-happy and ends up causing a stack overflow.

Months and often years of work go into most modern application development life cycles, so when it comes to deployment (whether for testing or even production) it can be a momentous occasion. While many continuous deployment-style practices try to reduce the difficulty and stress involved in deploying by keeping the process a frequent occurrence, it can still be a major challenge to deploy without introducing any number of problems.

Next up in our JavaScript Error Handling series we’re looking at the Property X Cannot Be Deleted TypeError in greater detail. The Property X Cannot Be Deleted TypeError is typically thrown when trying to delete an object property that is non-configurable.

Let’s face it: It can sometimes feel downright impossible to properly measure code quality throughout the entirety of the development life cycle, particularly for the some of the massive applications we see produced today. There are nearly as many different types of metrics and best practices out there as there are applications of which to measure. This abundance of choices and numerous complexities often lead to the question of what code quality metrics should management monitor?

As we approach the end of our all-encompassing Ruby Exception Handling series, today we’ll be taking a look at the SystemExit error, which is raised whenever the Kernel#exit method is invoked to terminate the current process.

Making our way through the .NET Exception Handling series, today we’ll take a closer look at the System.IndexOutOfRangeException. As indicated by its name, the System.IndexOutOfRangeException is raised when attempts are made to access an invalid index of a collection, such as a list or array.

Today in the continued journey through our JavaScript Error Handling series we’ll be exploring the Invalid Array Sort Argument TypeError. The Invalid Array Sort Argument TypeError is thrown by the Firefox JavaScript engine in a very specific situation: When the argument passed to the Array.prototype.sort() method isn’t a valid function.

Let’s be upfront about this right out of the gate: Defects are an inevitability at some point during the development life cycle, particularly for larger and more complicated projects. There’s no benefit to be gained by fooling ourselves into the unhealthy belief that all bugs and defects can be avoided. This attitude is dangerous, not only for technical leadership in the company but for customers and even the bottom line of the business as a whole. However, even though some defects are a given throughout the course of development, production defects can often be avoided with intelligent planning, coding practices, and – most importantly – thorough testing.

Today in our continued journey through our Ruby Exception Handling series we’ll be taking a closer look at the ZeroDivionError. As you may suspect the ZeroDivisionError occurs when attempting to divide a number by zero.

Next up in our JavaScript Error Handling series is the More Arguments Needed TypeError. The More Arguments Needed TypeError is typically thrown when calling a method or function that requires a minimum number of arguments that simply weren’t provided by the calling code.

Today we’ll be continuing our exploration of the common Structural design patterns as part of our much bigger Guide to Software Design Patterns series. Next up is the composite design pattern, which is used to separate an abstraction from its implementation so both can be modified on their own. Specifically, the composite pattern aims to treat singular object instances and collections of the same object types uniformly. This allows the client code to interact with this type of composited object the same throughout the code, regardless of whether it’s a singular instance or a collection of instances.

Moving along through our .NET Exception Handling series today we’ll take a closer look at the System.Net.WebException. While .NET provides numerous exceptions that are related to connectivity and web issues, the System.Net.WebException is one of the most generic (and thus most common) errors you’ll see in your own adventures.

Making our way through the Ruby Exception Handling series we have now arrived at the ThreadError class. ThreadErrors are raised anytime an invalid operation is attempted on a thread, plain and (somewhat) simple!

Moving along through our JavaScript Error Handling series today we’ll explore the X Is Read-Only TypeError in more detail. An X Is Read-Only TypeError is limited to strict mode and occurs when attempting to alter a read-only property.

During the first article in our How to Debug series we went over a few generalized debugging best practices that are applicable to most platforms and debugging tools. Next we dove into Visual Studio with Debugging with Visual Studio - Part 1 and saw how Visual Studio handles code navigation, debugging windows, tooltips, and much more.

Making our way through our .NET Exception Handling series, today we’ll take a closer look at the System.ArgumentNullException. Similar to the System.ArgumentException that we covered in another article the System.ArgumentNullException is the result of passing an invalid argument to a method – in this case, passing a null object when the method requires a non-null value.

Today we continue our journey through the common set of Structural design patterns within the larger Guide to Software Design Patterns series. Next on the docket is the bridge design pattern, which is intended to decouple the abstractions of an multiple objects from their actual implementation, so changing one will not effect the other.

Making our way through our JavaScript Error Handling series, today we’ll tackle the fun little error known as the X Is Not a Function TypeError. As indicated by the name itself, the X Is Not a Function TypeError is most often thrown when attempting to invoke a function() call on a value or object that doesn’t actually represent a function itself.

Moving along through our Ruby Exception Handling series, today we’ll be checking out the SystemCallError and it’s closely associated Errno subclasses. SystemCallErrors are raised during any low-level, platform-dependent exceptions like invalid IO calls and the like.

Today, as we continue along through our JavaScript Error Handling series, we’ll be taking a closer look at the "x" Is Not a Constructor TypeError. As the name suggests a "x" Is Not a Constructor TypeError is thrown when incorrectly trying to invoke the constructor of a variable or object that doesn’t actually have a constructor itself.

Next up in our JavaScript Error Handling series we’ll be going over the X Is (Not) Y TypeError. The X Is (Not) Y TypeError is just one of the many TypeErrors we’ll take a look at in this error handling series, which typically deal with accessing values that are not the appropriate data types. In this case, the X Is (Not) Y TypeError is a rather general-purpose error that is thrown most often when methods expect a certain data type as an argument, but are passed a different data type instead.

Today we continue our journey of exploring all the cool new features that ES6 JavaScript has to offer. This isn’t the first part in this series by any means and thus far we’ve covered quite a bit of ground:

Moving along through our JavaScript Error Handling series, today we’ll take a look at the Null or Undefined Has No Properties error. Null or Undefined Has No Properties is the first TypeError we’ve explored thus far in this series, which generally encompasses issues where values are accessed that are not of the expected type. The Null or Undefined Has No Properties error occurs specifically when attempting to call a property of the null object or undefined type.

In our first part of our How to Debug series we took a look at general best practices that apply to most debugging platforms and tools. Now we’re free to dig a bit deeper by looking at specific languages and tools. This week we’ll be examining tips on debugging with Visual Studio. While there are many versions of Visual Studio on the market, it’s always advisable to use the latest tools available whenever possible, so we’ll be using the latest Visual Studio 2017 as the basis for all our examples throughout this article.

Moving along through our .NET Exception Handling series, today we’ll dig into the System.InvalidCastException. Put simply, a System.InvalidCastException is thrown when trying to perform some type of conversion an object to an invalid type.
ga
In this article we’ll examine everything about the System.InvalidCastException, including where it sits within the .NET exception hierarchy and by giving a few code examples to illustrate how this exception might come about. Let’s get going!

The next stop along our trek through the Ruby Exception Handling series brings us to the realm of regular expressions and the RegexpError. Quite logically, the RegexpError occurs when trying to define a new regular expression that contains some form of an invalid pattern.

Today we’ve finally made it to the Structural pattern section of our Guide to Software Design Patterns series, and to celebrate we’ll be exploring the adapter design pattern (while possibly eating some delicious cake as well). Structuralpatterns are used to configure how entities interact with and are related to one another. Thus, the adapter pattern allows us to make two normally incompatible entities compatible with one another.

Moving along through our JavaScript Error Handling series, today we’ll take a closer look at the Unterminated String Literal SyntaxError. JavaScript requires that string literals be enclosed in quotations, whether that be single (') or double (") quotes. The Unterminated String Literal error is thrown when when a string is detected that doesn’t properly terminate, like when it is missing closing quotations.

In Part 1 of our ES6 JavaScript series we tackled the strange naming conventions that ECMAScript is finally settling on, then took a look at new features within JavaScript like default parameters, classes, and block-scoping with the let keyword. In Part 2 we explored constants, destructuring, and constant literals syntax. Today for Part 3 we’ll cover just one particular (yet exciting) new feature known as template literals, so let’s get to it!

Today our journey through the Ruby Exception Handling series takes us to our next stop, the FloatDomainError. A FloatDomainError is most commonly raised when trying to convert special kinds of Float values to other numeric classes which don’t support those particular special values.

Making our way through the .NET Exception Handling series, today we’ll dive into the depths of the System.NotImplementedException. Similar to System.ArgumentException and a handful of other exceptions of this type, the System.NotImplementedException is not an error that is accidentally thrown. Instead, a System.NotImplementedException is used when calling a method or accessor which exists, but has not yet been implemented. In large part, this is used to differentiate between methods that are fully implemented for production code and those that are still in development.

Making our way through the wonders of the JavaScript Error Handling series, today we’ll explore the Equality Mistyped as Assignment SyntaxError. The Equality Mistyped as Assignment error is thrown when an attempt is made to declare an assignment of a variable, where the parsing engine believes the intention was an equality test instead.

Making our way along through the Ruby Exception Handling series, today we’ll explore the RangeError within Ruby. Simply put, the RangeError is raised when a numerical value is provided to a Ruby method that falls outside the allowed range of values.

Continuing through our .NET Exception Handling series, today we’ll take a little gander at the System.ArgumentException. As the name implies, the System.ArgumentException is commonly thrown when there is an issue with a provided argument. As with a few other exceptions of its type, the System.ArgumentException is not thrown during normal execution by internal .NET classes or API calls but, instead, is commonly used by developers as an indication of an improper argument attempt.

Knowing how to debug is a critical aspect of every application development life cycle. Debugging allows developers to not only recognize that an exception has occurred, but to also then systematically traverse through the application’s execution until the culprit code can be located and fixed. Whether the resolution requires repairing a minor typo or even rewriting a massive component in the system, the simple act of debugging allows developers to (eventually) solve nearly every issue, given enough time and manpower to do so.

Continuing along through our Ruby Exception Handling series, today we’re going to take a closer look at the LocalJumpError. Put simply, a LocalJumpError is raised when a yield call is made inside a method that has code blockassociated with it.

Today we’re continuing our journey through our Guide to Software Design Patterns series with our final Creationalpattern: singleton. The purpose of the singleton pattern is to ensure that only a single instance of the object or class in question can exist at one time.

Today we’ll be continuing our expedition through our JavaScript Error Handling series by looking at another SyntaxError, the Missing Return in Function error. As the name implies, the Missing Return in Function error pops up when the JavaScript engine detects that a return or yield statement is being called outside of a function.

Making our way through the Ruby Exception Handling series, today we’ll take a dive into Ruby’s NameError. Simply put, the NameError is raised when a provided variable name or symbol is invalid or undefined.

Continuing our journey through the JavaScript Error Handling series, today we’ll be tackling the Redeclaration of Formal Parameter JavaScript error. The Redeclaration of Formal Parameter error occurs when attempting to redeclare a function parameter, within the function body itself, by using the let assignment.

Making our way through our .NET Exception Handling series, today we’re going to take a look at the System.Net.Sockets.SocketException. Typically, a System.Net.Sockets.SocketException is thrown when an error occurs within a socket, such as a failure to connect to a remote network.

Our next stop during our travels through the Guide to Software Design Patterns series has us exploring another Creational technique known as the prototype pattern. In the simplest terms, the prototype pattern allows for a new instance of an object to be created by duplicating or cloning an existing object, as opposed to creating a new object instance outright.

Next up in our adventure through the JavaScript Error Handling series we’ll be going over the Missing Bracket After Element List JavaScript error. As directly implied by the name itself, the Missing Bracket After Element List error is thrown when an array is initialized with incorrect syntax, such as a missing closing bracket (]) or comma (,).

The other week we covered the first part of a miniature series covering a trifecta of software development life cycle articles beginning with Object-Oriented Analysis and Design - What is it and how do you use it?. Shortly after its introduction, Object-Oriented Analysis and Design was the stepping off point for another new software design pattern, which we covered a few days later in Domain-Driven Design - What is it and how do you use it?. A few weeks prior, we also explored Test-Driven Development, which is also related to today’s topic.

Today, as we continue through our .NET Exception Handling series, we’ll be taking a closer look at the System.StackOverflowException. As indicated by the name, the System.StackOverflowException is thrown when a stack overflow occurs within .NET execution.

Today, our journey into the Guide to Software Design Patterns series takes us to yet another Creational design pattern: the builder method. In this article we’ll cover what the builder method is using both real world examples and functional C# code, so let’s get to it!

Today, as we move along through our JavaScript Error Handling series, we’ll be examining the Missing Brace After Property List JavaScript error. As the name implies, the Missing Brace After Property List error is another in the line of SyntaxErrors, which occurs specifically when initializing properties of an Object where the parser expects a closing brace (}) to appear.

Moving right along through our Ruby Exception Handling series, today we’ll be examining the StopIteration error.StopIteration is unique in the realm of Ruby exceptions, since it isn’t generated at run-time by something going haywire, but is instead manually raised by the developer when there’s a need to halt an active iteration.

Most developers are well-aware of the concepts of object-oriented development, but those same concepts originate from a broader approach to the entire software development life cycle known as object-oriented analysis and design (OOAD). OOAD is a technical method of analyzing and designing an application based on that system’s object models (the logical components of the system that interact with one another).

Taking the next glorious step down the shining path of our .NET Exception Handling series, today we’ll be looking over the amazing System.OutOfMemoryException. As the name implies, the System.OutOfMemoryException typically occurs when the common language runtime (CLR) is unable to allocate enough memory that would be necessary to perform the current operation.

Moving right along through our Guide to Software Design Patterns, today we’re going to take a deeper dive into the next Creational design pattern on the list: the abstract factory. The abstract factory is the final factorypattern we’ll be exploring in this series and, perhaps unsurprisingly, it is the most robust and detailed of all three factory patterns we’ll be covering. Simply put, the abstract factory allows you to create a factory of factories – a way to group similar factories together, without knowledge of their underlying classes or behavior.

Today, as we continue along through our .NET Exception Handling series, we’re going to take a look at the System.BadImageFormatException. System.BadImageFormatException has nothing to do with gifs or jpgs, but instead, occurs when a .NET application attempts to load a dynamic link library (.dll) or executable (.exe) that doesn’t match the proper format that the current common language runtime (CLR) expects.

In the world of software development, test-driven development (commonly shortened to tdd) is an well-known and commonly-used development methodology by which (failing) tests are initially created, and only then is the actual software code created, which aims to pass the newly-generated tests.

Next up in our deep dive through the Ruby Exception Handling series we’ll be dog-paddling our way around the KeyError. The KeyError is a descendant of the IndexError. Unlike the IndexError, which deals with Arrays, the KeyError deals with Hashes instead. Specifically, a KeyError occurs when a reference to a key within a hash is invalid or missing.

As we march along through our JavaScript Error Handling series, today we’ll be parading our way through the Missing Semicolon Before Statement JavaScript error. As the name implies, the Missing Semicolon Before Statement error is typically thrown when a semicolon (;) was forgotten somewhere in the code.

Kanban (or 看板, literally meaning a sign in Japanese), is used today to signify a form of manufacturing in which all necessary components are managed through the use of a card that indicates missing components. The purpose of kanban is to control inventory throughout the supply chain, within a manufacturing setting, via a practice known as just-in-time (JIT) manufacturing. This ensures that the supply and demand of manufacturing components are perfectly balanced with one another, largely eliminating wasted materials and time.

Today, as we continue our journey through our Guide to Software Design Patterns, we’ll keep on the path of Creational design by taking a closer look at the factory method pattern. The factory method is similar to the simple factory pattern that we explored previously, except the factory method provides a simple way to further abstract the underlying class (and associated logic) from the client that is making use of our factory.

Moving right along through the magical world of our .NET Exception Handling series, today we’re going to cover the System.InvalidOperationException. The System.InvalidOperationException is a fairly common exception, as it is typically thrown when there’s a failed attempt to invoke a method, caused by something other than invalid arguments passed to that method.

In this blog post, we’re going to demonstrate a simple shell script we cooked up to extract errors from logs sitting in an Elasticsearch database and then send those errors to Airbrake.

Scrum is easily one of the most well-known and commonly implemented software development frameworks in the world. At its core, scrum is actually an Agile framework. However, scrum is also technically a subset of Agile, since scrum adheres to a rather strict set of processes and practices.

Today we’ll be continuing our journey through our Ruby Exception Handling series by exploring the wonderful world of the Ruby IndexError. The IndexError is raised when there’s an attempted call to an element within an array, where the given index is out of bounds or invalid in some way.

A conceptual model is a representation of a system that uses concepts and ideas to form said representation.Conceptual modeling is used across many fields, ranging from the sciences to socioeconomics to software development.

Our first leg of the journey through our Guide to Software Design Patterns takes us into the world of creational design patterns, specifically the simple factory pattern. At its core, the simple factory design pattern is a form of abstraction, which hides the actual logic of implementation of an object so the initialization code can focus on usage, rather than the inner workings.

Kaizen is the Japanese word for improvement. In the realm of software development life cycles, kaizen expands on the notions of continuous integration and continuous development with its core concept of continuous improvement. This applies to all aspects of the organization, including both the project and the employees themselves.

As we continue down the beautiful path that winds through our .NET Exception Handling series, today we’ll be examining the System.Data.SqlClient.SqlException. The System.Data.SqlClient.SqlException is typically thrown when an accessed SQL Server returns a warning or error of its own.

We’re excited to announce the new major release of our .NET notifier library! Airbrake has seen some serious feature improvements and upgrades during the last couple of years, but Sharpbrake hasn’t gotten the love it deserved.

Continuing through our JavaScript Error Handling series, today we’ll be looking closely at the Missing Parenthesis After Argument List JavaScript error. The Missing Parenthesis After Argument List error can occur for a variety of reasons, but like most SyntaxErrors, it commonly pops up when there’s a typo, an operator is missing, or a string is not escaped properly.

The fundamental purpose of the Rational Unified Process is to provide a model for effectively implementing commercially proven approaches to development, for use throughout the entire software development life cycle. Taking elements from other iterative software development models, the Rational Unified Process framework was initially created by the Rational Software Corporation, which was bought out by IBM in 2003.

Continuing along through the .NET Exception Handling series, today we’re going to examine the ever-popular System.IO.FileNotFoundException. The System.IO.FileNotFoundException is common because, as the name suggests, it primarily rears its head when attempting to access a file that doesn’t exist.

For a variety of programming languages, the self (or this) keyword is a powerful tool, allowing developers to contextually refer to a particular class or object. This capability to refer to the current object, no matter the context, can be difficult to fully grasp, regardless of the language, and Ruby is no different.

Working with design patterns during software development can be tricky at times. Their purpose is to provide guidelines for dealing with particular problems that might arise during development. However, the sheer quantity of potential design patterns, combined with the intricacies of each pattern’s inner workings, can often make it challenging to select the correct pattern for your particular project, component, or programming language.

Next on the docket in our Ruby Exception Handling series, today we’re going to examine the EOFError in Ruby.EOFErrors are a descendants of the IOError class, and consequently, occur only in the specific scenario that an IO method is called for a file stream, in which that stream has already reached the end of the file.

Our journey through our Ruby Exception Handling series continues, as today we’re taking a look at the FiberError. A FiberError occurs when attempting to make a call to Fiber class methods, after the fiber has been terminated.

Automation and computerization are rapidly becoming hot-button issues, both journalistically and politically. As many workers are all too aware, the pace of technological advancement is dramatically impacting the jobs market, as much of the work previously performed by human laborers can now be completed by relatively inexpensive robots and computerized systems.

Scaled Agile Framework^®, also known as SAFe®, is an enterprise-scale development methodology, developed by Scaled Agile, Inc. SAFe combines Lean and Agile principles within a templated framework. Proponents of SAFe claim that it provides a significant increase in employee engagement, increased productivity, faster times to market, and overall higher quality.

.NET is among the most robust software frameworks on the market today, yet with that awesome power, comes the responsibility of managing a huge variety of exceptions. Given that .NET enabled many different languages across all sorts of platforms and devices, .NET must be capable of handling errors that deal with all manner of issues, from web traffic and I/O to operating system problems and database exceptions. In fact, the latest version of .NET has built-in classes to handle over 300 unique exceptions in total!

As we continue down the well-traveled road of Ruby Exception Handling series, today we’re taking a look at the UndefinedConversionError. An UndefinedConversionError is raised when using Encoding or String methods, and the transcoding process is unable to convert a character from one encoding to another.

If you want to know where a technology is going, sometimes it is effective to study where it has been. The Dynamic Systems Development Method (DSDM) is currently known as an agile development type, with features that are best suited to certain situations. However, many software developers on the inside will tell you that DSDM preceded agile development in total and should be considered a true precursor, because studying DSDM will lead you into a better understanding of agile development as a whole.

A new feature in the increasingly popular Jenkins automation server may affect how you implement DevOps - in a good way. Companies that are looking to create continuous delivery and continuous integration solutions are looking more and more to Jenkins because of its fast moving improvements. 54% of companies practicing continuous delivery are now using Jenkins, with that number expected to rise over the coming years.

Continuing right along through our JavaScript Error Handling series, today we’ll be taking a closer look at the Invalid Octal Constant warning. The Invalid Octal Constant warning is quite unique in the realm of all the JavaScript errors we’ve explored thus far, because it only appears in two very specific instances: when defining an octal literal value of 08 or 09.

Delving deeper into the misty (and mysterious) mountains of JavaScript Error Handling, we’ve come upon the frightening and dangerous lair of the beast known as the Invalid Strict with Complex Parameters error! [INSERT TERRIFIED SCREAMS]. The Invalid Strict with Complex Parameters error rears its ugly head anytime strict mode is enabled within a function that contains any sort of complex parameter.

Moving right along through our in-depth Ruby Exception Handling series, today we’re going to examine the InvalidByteSequenceError. An InvalidByteSequenceError is raised when utilizing Ruby’s internal Encoding or Stringmethods to transcode a string that contains an invalid byte for the particular encoding converters being utilized.

As we continue to make our way through the expansive Ruby Exception Handling series, today we’ll be taking a closer look at the CompatibilityError. CompatibilityErrors appear when dealing with encoding in Ruby, and specifically when attempts are made to compare two encoded values which have incompatible encoding types.

Sometimes the bane of management is letting go. Imagine that - working your entire career to gain the authority to outsource, then having trouble implementing that very policy! However, outsourcing in its many forms is sometimes the preferable business strategy. You may have an in house staff that is quite capable, but unable to scale with success. There is only so much volume that a core staff can take on, especially if your priority is quality coding. That’s where open source development can come in handy.

As our exploration through the Ruby Exception Handling series continues, today we’ll be examining the ConverterNotFoundError. ConverterNotFoundErrors appear in Ruby when attempting to use any of the variety of transcoding methods provided by Ruby, but in doing so, passing an invalid converter that Ruby isn’t aware of.

Today, as we continue through the next thrilling segment in our JavaScript Error Handling series, we’re examining the Reference to Undefined Property error with a fine-toothed comb. The Reference to Undefined Property error can only appear when strict mode is enabled, and will occur when the code attempts to access an object property that simply doesn’t exist.

Software executives constantly play the game of balancing extra detail with extra overhead. Most software efforts eventually trend towards the latter, as budgets dwindle and deadlines loom. Eventually, a company may adopt a policy that is too far in line with the finance department and not enough with quality control. However, defect tracking, if properly implemented, has the ability to benefit development rather than slow it down.

The way that you handle the revisions process with clients will determine if your customer services can be deployed in a timely fashion. Some clients will take up your time just because you show that you have it, and this is no way to do business.

APIs should now be a key component of your deployment strategy. Without a widespread deployment of APIs, you can forget about deploying your final product in a timely fashion and within your budget. What does this mean for your demand versus your deployment?

Whether your productivity is resting comfortably in a profit bearing zone or you are actively looking for bottlenecks and time sinks, process improvement should be a priority within your company. The Capability Maturity Model Integration (CMMI) certification process is all the rage this season, and with good reason. Created and administered through Carnegie Mellon University, CMMI certification is currently required to obtain a growing number of government contracts, especially in the area of software development.

The steady journey through our extensive Ruby Exception Handling series continues. Today we’ll be taking a closer look at the UncaughtThrowError. UncaughtThrowError is a descendant class of the ArgumentError, which is, in turn, a descendant of the StandardError superclass we all know and love. UncaughtThrowError is, as the name implies, raised when a throw is called but not properly caught by an appropriate catch block.

When estimating the effort of a project, the planning fallacy often causes a build-up of process overrun. Put simply, people always underestimate the amount of time they will take to complete work. Add to this the natural inclination to claim a better production standard than your lateral colleagues in front of top brass, and you have a recipe for a problem.

As agile as we all want to be, projects invariably face time and budget constraints that must be worked around. Outside of the world of idealism and theory, the way that we prioritize solutions is essential to building deliverables that satisfy the requirements and the expectations of stakeholders. Since the Moscow method was integrated into the DSDM Consortium, savvy companies have been using it to reorganize thinking within a time boxed process.

If you are trying to compete anywhere near the common man’s B2C product retail industry, the efficiency of your product management system should be a priority. The complexity of software development means that you have virtually endless potential for confusion without a proper system in place to ensure maximum efficiency and timely task completion.

Next on the list in our extensive JavaScript Error Handling series we’re going to examine the Invalid Left-Hand Assignment error in greater detail. The Invalid Left-Hand Assignment error is a sub-object of ReferenceError and is thrown, as the name implies, when code attempts to perform an invalid assignment somewhere.

Agile is the buzzword that everyone is talking about, and dev teams may get too caught up in replacing agile activities for hard results. Agile itself is continually improving its metrics, and companies have more opportunity than ever to apply only the metrics that achieve transformative results. When a dev team dedicates itself to results over simply applying the latest so-called agile metric to say “We’re agile,” great things happen. Here are vetted KPMs that translate into real results.

Next on the docket for our  Ruby Exception Handling  series, we’re taking a look at the SignalException class. SignalException is a subclass descendant of the Exception superclass, and occurs when a process monitored by Ruby receives a signal via the operating system.

The standalone metrics of past business generations are not relevant to most results oriented companies these days. End users do not concern themselves with scripts executed, errors discovered or total code lines written. These traditional metrics may mean something to the dev team, but it has no direct effect on customer facing quality.

Extreme Programming is a software development methodology designed to improve the quality of software and its ability to properly adapt to the changing needs of the customer or client. During the mid and late nineties, while working on the Chrysler Comprehensive Compensation System (C3) to help manage the company’s payroll, software engineer Ken Beck first developed the Extreme Programming methodology. In October 1999, he published Extreme Programming Explained, detailing the entire method for others, and shortly thereafter the official website was launched as well.

Great news for IT consultants: Agile is everywhere, and continuous integration may actually prove itself to be the media buzzword that actually increases efficiency when taken seriously! Recommend away. Moving forward into the fifth generation of computing led by AI and virtualization, Platform as a Service (PaaS) technology along with new ways of app packaging and scaling provide even the smallest companies with the ability to continuously integrate in the cloud. What will separate winners from losers in this era of business is a company’s ability to efficiently upgrade its efficiency through continuous integration.

Today as we progress through our JavaScript Error Handling series we’re going to take a dive into the Deprecated Caller/Deprecated Arguments error in all its magnificent glory. The Deprecated Caller/Deprecated Arguments error appears when code attempts to call one of two specific properties of a function while strict mode is enabled: Function.caller or Function.arguments.

The four tenants of the Agile Manifesto are certainly a sexy quartet. Difficult to properly harmonize at times, but certainly helpful to companies looking to move forward in an accelerating technological environment. However, too many agile developers forget the sentence that the 2001 Utah ski lodge group placed right after the Big Four:

Back in February of 2001, a small group of seventeen software developers met in the high elevations of Snowbird, Utah to discuss software development methodologies. Out of this assemblage emerged the Manifesto for Agile Software Development, a publication that outlined the group’s vision for lightweight software development, and which would go on to dramatically shape the landscape of modern software development for years to come, up to the present day.

You know those errors you never get around to fixing? And then every time you deploy new code and auto-resolve errors, they pop back up again? And it overflows your inbox (or Slack channel), and you’re like “I know…I need to fix this…stop reminding me!!!”

As we stroll our way down the winding path of our  JavaScript Error Handling  series, today we’re stopping to smell the aroma of the Negative Repeat Count error. The Negative Repeat Count error, similar to the Infinite Repeat Count error, occurs when using the repeat() method of a String object in JavaScript, but in this case when the count parameter passed to that method is a  negative  value.

Media can report that employee acquisitions are “bullish,” but HR knows the truth. Hiring developers (especially the good ones) is going to be a slog using traditional methods. The best devs seem to be purposefully hiding from recruiters who employ a traditional process, and with good reason: A traditional process is usually linked to a traditional company. Young, vibrant, bleeding edge developers have been showing their disdain towards these companies for quite a few years now.

Today as we continue our journey through the wide world of  Ruby Exception Handling , we’re going to examine the Interrupt exception class. Interrupt is a subclass descendant of the Exception superclass, and occurs when a specific interrupt signal is received by the active Ruby process, such as when the user manually halts via Ctrl-C.

Today we’ll be taking a closer look at a unique, yet rather popular, software development model, colloquially known as the Big Bang model. While the tenets of the Big Bang model, such as they are, are almost excessively simple, use of the model should not be wholly discarded or ignored, as it can be a powerful tool to manage the software development life cycle (SDLC) of a wide range of projects.

Today as we plow ahead through our  JavaScript Error Handling  series we’re going to be tackling the Infinite Repeat Counterror. The Infinite Repeat Count error occurs during the use of the repeat() method of a String object in JavaScript, and specifically when the count parameter passed to that method is too large.

All technical debt should ideally be eliminated; however, product iteration cycles END. Executives demand certain things on certain dates. These deadlines are a part of the coding process - there is a time component that works right alongside syntax, form, elegance and function, like it or not. No matter how agile you want to be, in order to make a realistic living as a tech pro, you are going to have to make some technical debt compromises! The question is how to minimize and strategically locate this debt so that it actually works in your favor.

This is an exciting day in the life of our  Ruby Exception Handling  series, as we tackle the big daddy of all Ruby exceptions, the StandardError. StandardError is a superclass with many exception subclasses of its own, but like all errors, it descends from the Exception superclass. StandardErrors occur anytime a rescue clause catches an exception  without  an explicit Exception class specified.

Next up on the list of articles in our  JavaScript Error Handling  series we take a closer look at the Undefined Variable error. The Undefined Variable error is thrown when a reference to a variable or object is made in code that either doesn’t exist, or is outside the scope of the executing code.

A truly agile development team refines how work is managed as well as how it gets done. The literal concept of agile development means working through iterations rather than through sequences.However, the spirit of agile is cultural as well as procedural - if your company does not make lean software development a lifestyle, your teams will lose time and efficiency constantly redeveloping methods that should become automatic very quickly.

Today as we progress through our  JavaScript Error Handling  series we’re going to take a closer look at the Assignment to Undeclared Variable error in all its magnificent glory. The Assignment to Undeclared Variable error crops up anytime code attempts to assign a value to a variable that has yet to be declared (via the var keyword).

As we plow ahead through our adventure with the Ruby Exception Handling series, today we’re examining the SecurityError exception class, which is raised anytime Ruby attempts a potentially unsafe operation.

The V-Model is a unique, linear development methodology used during a software development life cycle (SDLC). The V-Model focuses on a fairly typical waterfall-esque method that follows strict, step-by-step stages. While initial stages are broad design stages, progress proceeds down through more and more granular stages, leading into implementation and coding, and finally back through all testing stages prior to completion of the project.

Next on the docket for our continued dive into the JavaScript Error Handling series is the Invalid Radix error. The Invalid Radix error occurs in a specific instance, when the toString() method of a Number object in JavaScript is called, and it includes an invalid passed parameter representing the radix (or base) with which to convert the number to a string.

Next on the docket for our Ruby Exception Handling series, we’re taking a look at the NotImplementedError exception class. NotImplementedError is a subclass descendant of the ScriptError superclass, and occurs when Ruby attempts to utilize a feature or method that isn’t implemented for the current platform or Ruby installation.

Like most programming languages, Python offers an extremely powerful development platform to create some of the most useful and robust applications imaginable. However, as Spider-Man and Winston Churchill have taught us, _with great power comes great responsibility. _Here are our thoughts on Python best practices to help you harness everything Python has to offer.

Today, as we continue along through our in-depth JavaScript Error Handling series, we’re going to take a look at the ‘Precision is out of range’ error. The Invalid Precision error will occur anytime a number object is provided an invalid numeric value for one of the precision-based JavaScript methods, which we’ll explore more below.

Among programmers and Computer Science experts_,_ Java is recognized as a market leader and the number one programming language in the enterprise development arena. So today we bring you a list of some of our favorite Java Blogs from around the world focusing on different aspects of Java. We hope you’ll enjoy our recommendations.

The iterative model is a particular implementation of a software development life cycle (SDLC) that focuses on an initial, simplified implementation, which then progressively gains more complexity and a broader feature set until the final system is complete. When discussing the iterative method, the concept of incremental development will also often be used liberally and interchangeably, which describes the incremental alterations made during the design and implementation of each new iteration.

Chugging right along through our Ruby Exception Handling series, our next stop takes us to the LoadError exception class. LoadError is a subclass descendant of the ScriptError superclass, and occurs when Ruby attempts to load a file (via require or otherwise) that simply doesn’t exist.

AngularJS has rapidly become one of the hottest new trends in development for creating powerful web or local applications on virtually any platform. While this extraordinary platform heralds itself as a MVW (Model-View-Whatever) framework - and is therefore suited for whatever your team or project requires - it can also be an overwhelmingly daunting foundation to build off of. To help alleviate any potential vertigo as you gaze down from the mountain of potential that is AngularJS, we’ve put together a handful of AngularJS best practices to keep your code clean and your mind (somewhat) sane.

Plowing straight ahead through our JavaScript Error Handling series, today we’ll be exploring the fun world of the Invalid Code Point error.

First introduced by Dr. Winston W. Royce in a paper published in 1970, the waterfall model is a software development process. The waterfall model emphasizes that a logical progression of steps be taken throughout the software development life cycle (SDLC), much like the cascading steps down an incremental waterfall. While the popularity of the waterfall model has waned over recent years in favor of more agile methodologies, the logical nature of the sequential process used in the waterfall method cannot be denied, and it remains a common design process in the industry.

Today we continue the Ruby Exception Handling series by taking a look at the ScriptError exception class. ScriptError is actually a superclass, which means it is inherited by other exception classes, and thus when a ScriptError occurs, Ruby determines which of the subclasses is most relevant and raises that error for further examination.

Are you looking for one simple way to make Java code easier to maintain, debug, and develop? If so, you should simply adhere to Java best practices in order to produce great code. Great code doesn’t just work well; it is also readable, maintainable, and often, reusable. When you get confronted by a deadline and just needs to get the thing to work, it’s tempting to toss in some hacks. However, these shortcuts are likely to punish you later when you need to debug or upgrade your scripts. If you get into the habit of writing code well, you will save yourself time and money in the end.

Next in our Ruby Exception Handling series we’ll be examining the dreaded NoMemoryError exception. As the name implies, a NoMemoryError can occur within Ruby anytime the system attempts to allocate more memory than Ruby can provide or is allowed.

Technical debt is an ever-present issue in software creation that becomes bigger as a project scales. Although you may not be able to see technical debt, you are paying it all the time if you are not looking for it! Is it ever acceptable, and how should you work to reduce it as much as possible?

Today in our continued journey through our JavaScript Error Handling series, we’re examining the InternalError object known as the Recursion error.

People who develop and maintain web applications usually dread a 500 Internal Server Error. This isn’t because these errors are usually hard to fix, however. It’s because the error is usually not specific and can occur for a number of different reasons. The best way to debug the error depends upon the server and what’s actually running at the time. Consider some debugging tips to help diagnose and fix common causes of this problem.

Ruby features a plethora of built-in classes to dramatically simplify exception handling and management. At the top-most level of the exception class hierarchy resides the Exception class, the monolithic parent class of over a half-dozen subclasses that typically regulate the grunt work of Ruby exception handling.

Rapid application development (RAD) describes a method of software development which heavily emphasizes rapid prototyping and iterative delivery. The RAD model is, therefore, a sharp alternative to the typical waterfall development model, which often focuses largely on planning and sequential design practices. First introduced in 1991 in James Martin’s book by the same name, rapid application development has become one of the most popular and powerful development methods, which falls under the parental category of agile development techniques.

The powerful JavaScript language and development platform provides a number of useful core object constructors that allow for simple exception and error administration. JavaScript error handling is typically performed through the generic Error object, or from any of a number of core error constructors.

Every good developer relies on having a collection of helpful programming tools at their fingertips. Here are some of our recommendations, separated, for ease-of-use into three categories: generic tools, specific free tools and specific paid tools.

JavaScript is a high-level interpreted language that’s supported by all modern web browsers and most websites. It’s one of the three core technologies used by the World Wide Web (WWW), along with CSS and HTML. JavaScript supports object-oriented programming styles and has an Application Programming Interface (API) that allows programmers to work with arrays, regular expressions and text. However, JavaScript depends on its host environment to perform I/O functions such as graphics, networking and storage. JavaScript Frameworks and Libraries allow programmers to develop applications more easily for web-centric technologies such as AJAX.

Programming podcasts are fast becoming a fun way to keep up-to-date on developments in the programming world and learn new skills, particularly for those of us whose dominant learning style isn’t reading-based.

Bugs in your code might be hurting more than just the quality of your software. We dug up this infographic from SourceNinja that outlines the financial pitfalls of bugs in code - especially open source code. The findings are eye-opening!

Some more specific takes on SDLC include:

This summer we relaunched and refreshed the Airbrake docs. The docs were moved in-house, open-sourced on GitHub, given a style overhaul, and are now available at airbrake.io/docs. We hope the new docs provide you with a cohesive and enjoyable experience, helping you become an expert Airbraker one doc at a time.

On November 24, we will stop supporting the Airbrake v4 Ruby gem, so we can focus our efforts on v5.

Knowing that something has gone wrong is pretty valuable. Companies and software teams spend lots of time, energy, and other resources trying to find what has gone wrong and where the problem is.

During the last 6 months, we’ve been collecting lots of feedback from Airbrake users, and we’ve been listening! We’re excited to announce the release of the most requested feature, aggregated error reports, or ‘aggregations’ for short.

We would like to welcome Loopline Systems as the 35th Airbraker in our “Awesome Airbrakers” series.

What value does Loopline Systems bring to its customers?

Loopline Systems offers a lightweight SaaS solution which is easy to implement and provides ongoing, actionable insights for executives and employees by linking data on performance with personal potential and contentment. By means of guided processes, loopline fosters individual committment, enabling high-quality feedback and development.

What do you like about Airbrake?

We where looking for a pure Application Monitoring solution without any noise besides that. Some other tools we used added infrastructure monitoring on top. But we use nagios and cacti for that already :)

Airbrake really focuses on the main use case, and does that pretty well.

The integrations are super helpful. We use the Jira and Slack integration. Having errors reported to Slack immediately helps us react as fast as possible. The thing with errors is: You will have them, but you need to see them.

The Airbrake Support is great, it usually takes max 24 hours to get answers. 24 hours sounds long, but we are based in Germany. So due to the time delay direct communication is not possible most of the time. Having an answer the next day is perfect and suitable most of the time.

We are excited to announce the new major release of our Ruby notifier library for Airbrake Bug Tracker!

Fig. 1 — Arthur, our mascot flying the Ruby flag

It was as clear as day that the gem needed a major update. The code was hard to maintain, the issue tracker had too many unresolved issues, and some important pull requests couldn’t be easily merged because they diverged from the master branch. While these problems could be fixed in a minor release, we also wanted to improve our library API, simplify the configuration process, and add missing integrations.

Meet the new notifier

The new Airbrake gem (v5) is a complete rewrite from scratch. Moreover, it consists of two parts! We have split the library into airbrake and airbrake-ruby.

Fig. 2 — The new Airbrake library consists of two gems

Here at Airbrake, we use Intercom.io for our customer engagement, and one of their fun features allows you to create a map of all your active customers. Never heard of it? Here’s a quick description from the Intercom blog.

We knew that great engineering teams from all over the world use Airbrake, but even we were surprised at just how global our users are. Check out some of these facts about Airbrake users:

• Engineers from over 4,300 cities and over 100 countries!
• Over 100 users from throughout Africa , and hundreds in South America
• Users in all 50 United States and all 10 Canadian Provinces

We would like to welcome Cucumber Tony as the 35th Airbraker in our “Awesome Airbrakers” series.  

What value does Cucumber WiFi bring to it’s customers?

Full stack Wi-Fi platform for small and medium enterprises. Transforming the way people use Wi-Fi.

What do you like about Airbrake?

The support team are always there, always helpful and always answer the questions quickly. That’s a big winner for us. We obviously use Airbrake for the default exception handling that comes built it. That’s great for finding the big bugs in our software. In fact, it’s been a better tool for discovering dead servers than the server monitoring tools we use.

More recently, we’ve been using it to log non-critical errors that wouldn’t throw an exception. Previously, we were just logging these to syslog but that was too much to manage. Now we all get a notification when an event happens to a customer, for example. Our customers love the realtime, proactive support we can offer as a result of using Airbrake.

How do you normally deal with Airbrake exception reports?

*This blog post was prepared by one of Airbrake awesome users; Federico Saravia.

At Citrusbyte, we’ve been using Airbrake for years, on a variety of projects, including AT&T mHealth and AT&T M2X. It has made our lives easier from Day 1. Now, we want to share our story and what we have learned along the way to help YOU take full advantage of this awesome service.

On using error services

Errors are a common thing in complex software projects — your team can (and should) work hard to squash them before reaching production. But, from time to time, a nasty little bug may make it to production and give you and your users a hard time.

Software bugs in production are often really hard to identify, especially because they often have really low visibility due to some the following factors:

• Your users are the ones stumbling on them and their bug reports are not always accurate enough.
• They often occur in edge case scenarios and are difficult to reproduce.
• You may not know exactly when they occurred.
• You will need to spend long hours looking at logs in order to find a clue into what happened.

For this and many other reasons, it seems downright crazy not to use an error service that helps you address these issues and makes it easier for you to find and squash bugs faster and more easily. We chose Aibrake because it has a lot of powerful features that make it really easy to deal with errors and lets us know right away when something goes wrong.

Here is how we are using Airbrake to make sure our application is always error free:

We would like to welcome TheSquareFoot as the 33rd Airbraker in our “Awesome Airbrakers” series.

What value does TheSquareFoot bring to it’s customers?

We are a tech-enabled commercial real estate brokerage. Our brokers help get companies into office space and our tech team helps to automate and simplify the bulk of our broker’s workload, as well as clients the ability to browse space all over the country.

What do you like about Airbrake?

Airbrake makes staying top of our production errors an effortless affair.

We would like to welcome Base Directory as the 32nd Airbraker in our “Awesome Airbrakers” series.

What value does Base Directory provide?

Base Directory makes it easier for service members and their families to find information on military bases around the world. We take publicly available information from difficult to navigate government websites and data sets and present it in a standardized and user-friendly way through our website and mobile apps.

What do you like about Airbrake?

We love how Airbrake lets us know immediately when an exception occurs. We hate for any of our users to have a poor experience with Base Directory, so we really try to stay on top of errors that are affecting user experience, and ensure any errors are resolved same day or as close to immediately as possible.

We would like to welcome Laurel & Wolf as the 31st Airbraker in our “Awesome Airbrakers” series.

What value does Laurel & Wolf provide?

We believe in the power of great design and how it can transform the way we live, work, and love! If you think about it, the way furniture is placed in a space will dictate the way people interact with one another. However, since the creation of interior design as a profession, interior designers have only been accessible to the very wealthy. Homes and businesses all over the world have suffered in drab silence as they waited wistfully to be improved. They watched their swankier counterparts remodel, renovate, and redecorate, wishing desperately that their time would come.

What do you like about Airbrake?

Airbrake helps building better product by allowing us to know what issues our customers are experiencing before they even tell us about it. Early on in our company, Engineering would handle support issues directly with customers, since we didn’t have the amazing Client Services team that we do now. I think a big part of our early success as a company is due to us emailing customers acknowledging the error they’ve just seen, and letting them know that we are either handling it manually for them, or pushing up a fix to production as we speak.

We would like to welcome Your Computer Genius as the 30th Airbraker in our “Awesome Airbrakers” series.

What value does Your Computer Genius provide?

We manage all aspects of software development for medium-size businesses that need custom software, from helping with CIO tasks and budgeting to running blended agile teams.

What do you like about Airbrake?

Airbrake is great as a console for monitoring exceptions.

We use it in both the Dev and Prod environments — it’s really cool that Airbrake automatically sorts that out.

We would like to welcome Coride as the 28th Airbraker in our “Awesome Airbrakers” series.

<img class=“mb-3” src="/blog/awesome-airbrakers/coride/unnamed.png “Coride logo”"/>
What value does your company provide?

We help people share rides between cities. That means passengers can find fun and cheap rides and drivers get paid to drive where you are already going.

What do you like about Airbrake?

Airbrake saves my butt!

We would like to welcome Citrusbyte as the 27th Airbraker in our “Awesome Airbrakers” series.

What value does your company provide?

Citrusbyte works with you to build your startup, modernize and rebuild your technology, and help you enter new markets with new products. We advise you on all facets of the product lifecycle — from engineering and design to marketing and sales — helping you make informed decisions along the way.

What do you like about Airbrake?

We really like the visibility that Airbrake gives over unexpected errors that otherwise will be buried among huge piles of logs. It is a great tool to provide context information about each occurrence of an error making it an easy job to reproduce it and fix it ASAP.

It is also great that it allows us to set a different project pear each environment so we can even report errors from our development environments and use the UI to better analyze them.

We would like to welcome Factor 75 house as the 26th Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

We deliver healthy, prepared meals to people who want to perform at their peak.

What do you like about Airbrake?

Airbrake brings the problems to me, so I don’t have to go searching for them. With a very small development team, I don’t have the time and energy to constantly monitor our logs for issues. I’m grateful I can outsource that responsibility to Airbrake.

We would like to welcome Homestay house as the 25th Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

We focus on hosts that actually live in the house they’re sharing (as opposed to empty apartments), as we believe the interaction with local people is the best way to get a feel for a given place and culture.

What do you like about Airbrake?

With Airbrake we know when something is wrong before problems escalate to bigger proportions. Instead of waiting for customers to complain, we can rely on Airbrake telling us when something is not right.
This allows us to fix bugs very quickly and effectively.

We would like to welcome Once Matchmaking house as the 24th Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

We are a free matchmaking service! Our matchmakers set each user up with one handpicked match per day. Matches can be viewed on our app (getonce.com/dl), with a website version soon to come!

What do you like about Airbrake?

Airbrake has easy setup in addition to instant, concise, exhaustive reports. This helps us iterate quickly and be reactive on our infrastructure health.

We would like to welcome UrbisPro house as the 23rd Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

We provide map based searching of data that Land Surveyors in Australia need. Previously they had to use forms and pdf’s. By providing tailored visualisations we increase workflow productivity

What do you like about Airbrake?

Proactive customer support. We have very loyal 6+ year customers as they trust us to know what goes wrong before they get frustrated and have to call/email us.

We would like to welcome PractiTest house as the 22nd Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

PractiTest is a leading QA Management solution for Agile Testing, enabling IT organizations to ensure visibility and communication at all levels. As well as helping project development teams streamline and manage their testing processes while providing management with a clear and simple view of their project status at all times.

PractiTest can fully integrate with existing systems such as JIRA, Jenkins, Sellenium, Redmine and more.

What do you like about Airbrake?

We know of problems in an earlier stage, and able to solve them quickly.

We would like to welcome Softwhisper mobile development house as the 21st Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

At Softwhisper we do most of our work developing apps for our clients. We have to track errors occurred on any platform, Rails based API, iOS and Android apps. Thanks to Airbrake.io we can anticipate the client on reporting issues and deploy hot fixes as quick as we develop. Traces, environments vars and all the info provided save us from search on dozens of sys logs. Awesome job :).

What do you like about Airbrake?

Error reports give us many valuable information. Airbrake speeds up bug fixing in our projects.

We would like to welcome STAQ as the 20th Airbraker in our “Awesome Airbrakers” series.

What value does your company provide?

Revenue management and analysis for the digital advertising industry.

We would like to welcome One Month as the 19th Airbraker in our “Awesome Airbrakers” series.

What value does your company provide?

One Month is an online education company teaching people how to advance their career, build their own app, or grow their business. We teach Ruby on Rails, HTML, Growth Hacking, Content Marketing, and more.

We would like to welcome Drawfolio as the 18th Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

Drawfolio is a cloud web platform where illustrators and graphic artists can build their own portfolio website in a few minutes with no programming skills.

We would like to welcome aircargobook as the 17th Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

We connect forwarding agents, airlines and trucking companies, and help to find the right business partner. Forwarders can enter shipment requests they got from their customers and we will assist them to get competitive prices from more airlines they could get writing emails and calling.

We would like to welcome Hubstaff as the 15th Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

We make a time tracking and proof of work platform used by over 8k companies. It allows you to see not only how much people are working, but when and on what. It completely changes how you manage your team.

We would like to welcome AthleteTrax as the 14th Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

AthleteTrax provides a one-stop shop for sports facilities and organizations through its Web and mobile apps that offer registration & payment collection, communication, scheduling, fundraising, and video/workout tracking tools.

We would like to welcome Mingle2 Dating App as the 14th Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

****One of the top free online dating companies with over 11 million members.

Web/Mobile/IOS/Android Apps.

We would like to welcome Vindi as the 13th Airbraker in our “Awesome Airbrakers” series.

What value does Vindi provide?

Vindi is a Brazilian startup with a focus on subscription billing, recurring billing, intelligent checkout, and lost revenue recovery. A complete gateway and fraud prevention.

We would like to welcome Curiator as the 12th Airbraker in our “Awesome Airbrakers” series.

What value does your app provide?

Curiator is a platform for art enthusiasts to collect and discover fine art online. Think of it as a digital, collaborative art collection to which people contribute their favorite art and discover new art through each other.

We would like to welcome Bloomfire as the 11th Airbraker in our “Awesome Airbrakers” series.

What value does your company provide?

We help organizations & communities share & organize their collective knowledge so that employees are engaged and things get done. We bridge the gap between those that need to know with those that do. None of us is as smart as all of us.

W e are happy to welcome Jenendra Jain to Airbrake Interviews. Jenendra is a software development engineer - test, at Amazon, and a former senior test engineer at Microsoft, and we are going to talk about test automation challenges and how to overcome them.

Hi Jenendra. Could you tell us about you and how you started your career?

Before joining Amazon India in 2011, I started my career in mid 2008 with the ERP division of Microsoft. They use SAP platform with all the development focused towards how their business is handled in real world. Being right out of college I had no idea what SAP, or for that matter, any ERP Software is. I was given an option to be either SDET or SDE. Being an SDET was my choice and for the 3.5 years I spent with MS-SAP division, I learned a lot about business processes - after all, to test something you need to know the heart of the module. As an SDET I picked up the foundation of automation and so far have worked with QTP, VU-Gen, QC, Selenium, TestNG and Appium automation tools.

In talking about Test Automation challenges, many software engineers believe it’s difficult to implement, do you agree with that and why?

Airbrake Notifiers send exceptions from your applications to Airbrake. The Notifiers are created by the developer community. Having a wide variety of notifiers for different programming languages and frameworks enables users to keep track of exceptions from all kinds of applications.

This time we are featuringRoberto Ostinelli, who has written Lager-Airbrake notifier, a backend for Lager a logging framework for Erlang.

Roberto:

I have a great pleasure to announce that today I’ve released Lager-Airbrake notifier.

If you are already using the popular logging framework Lager) by Basho in your application, you might consider having an easy drop in component that will report the errors with the desired level of severity to AirBrake.

Lager-Airbrake works as a Lager backend, it is therefore fully integrated with it, and easy to setup.

In your project’s rebar.config file, add lager_airbrake as a dependency:

{<span class="pl-c1">lager_airbrake</span>, <span class="pl-s"><span class="pl-pds">"</span>.*<span class="pl-pds">"</span></span>, {<span class="pl-c1">git</span>, <span class="pl-s"><span class="pl-pds">"</span>git://github.com/ostinelli/lager_airbrake.git<span class="pl-pds">"</span></span>, <span class="pl-s"><span class="pl-pds">"</span>master<span class="pl-pds">"</span></span>}}

Then include lager_airbrake_backend in your lager configuration:

<img class=“mb-3” src="/blog/interview/test-automation-benefits-challenges-interview-bernardo-rivas-microsoft/1-color.png “Bernardo Rivas, Microsoft”"/>What is Software Test Automation? and how would a software engineer at Microsoft describe it? We had the pleasure to meet Bernardo Rivas, who works at Microsoft as a software engineer with a solid experience in C#, testing, test planning and automation.

Hi Bernardo and welcome to Airbrake Interviews!

First, we’d like to know, how did you start your career?

I started working in 2007 in Mexico City when I was still in college for a company called Stream Nova. They are a Microsoft partner which means that all their development is done in C# using SQL Server and, at the time, The Official Microsoft ASP.NET Site on IIS. I joined the company not knowing much about any of those technologies. I didn’t even know what a stored procedure was. I worked there for two years until I got my B.S. in Computer Science and had worked two big projects where I learned all the basics. That year I moved to Seattle to work with Microsoft as an SDET. I’ve worked with the Dynamics, Photosynth, Customer Support and Service, Bing and SQL Server teams where I focused mostly on virtualization, development of test tools and test automation.

Software test automation is a trending concept with many definitions, what does test automation mean ?

Do you love programming comics? Are you a fan of XKCD comics? Here are the top 10 programmers comics that stackoverflow users voted for!

Programming Comic #10

<img class=“mb-3” src="/blog/comics/top-10-programming-comics-cartoons-selected-by-stackoverflow-users/10.png “Top programming comic (cartoon”/> #10")

Programming Comic #9

<img class=“mb-3” src="/blog/comics/top-10-programming-comics-cartoons-selected-by-stackoverflow-users/9.png “Top programming comic (cartoon”/> #9")

System Development Life Cycle (SDLC) is a series of six main phases to create a hardware system only, a software system only or a combination of both to meet or exceed customer’s expectations.

System is a broad and a general term, and as per to Wikipedia; “A system is a set of interacting or interdependent components forming an integrated whole” it’s a term that can be used in different industries, therefore Software Development Life Cycle is a limited term that explains the phases of creating a software component that integrates with other software components to create the whole system.

Some more specific takes on SDLC include:

| Rapid Application Development | Test-Driven Development | Waterfall Model | | Iterative Model | Extreme Programming | Scaled Agile Framework | | Agile Model | Scrum | Rational Unified Process | | Big Bang Model | V-Model | Conceptual Model | | Kaizen Model | Kanban Model | Spiral Model |

Below we’ll take a general look on System Development Life Cycle phases, bearing in mind that each system is different from the other in terms of complexity, required components and expected solutions and functionalities:

System Development Life Cycle Phases:

<img class=“mb-3” src="/blog/sdlc/what-is-system-development-life-cycle/10917729_1514959615431155_1766053214_n.jpg “system development life cycle phases”"/>

1- System Planning 

The Planning phase is the most crucial step in creating a successful system, during this phase you decide exactly what you want to do and the problems you’re trying to solve, by:

Once you’ve hit the coding phase of the software development life cycle, it’s time to keep on top of bugs. There is much debate on the cost of fixing bugs early in the software development life cycle versus later, after implementation and deployment. Software developers can make an argument that fixing bugs early is the best strategy.

We’d like to talk about a new approach to mobile development, dubbed Mobile-D. The method’s purpose is to establish a functional, agile archetype for software development. It’s also useful in other applications, such as financial or logistical applications.

Effectively handling browser-generated errors, like much of web development, has long been a difficult, error-prone and highly arcane practice. Browser differences, inline event handlers, frameworks and plugins without canonical error-handling attachment points, and callback hell have all contributed to the bruxism that plagues front-end devs.

Airbrake exists to make devs lives easier, and not even the browser is exempt from our efforts. We’ve taken a long hard look at the state of tooling out there, and delivered tooling that we feel does just the right amount of heavy lifting while allowing developers to integrate the tool in ways that make sense for their environment.

Easy things aren’t easy

For years, most browsers have supported the window.onerror event to varying degrees. Scripts run inline have fired this error, as have errors triggered by missing resources including scripts and images.

Unfortunately, errors handled this way lack what is arguably the most important piece of information an error can carry, its stack trace.

A number of error-handling tools hook into window.onerror and some even attempt to attach additional information to errors propagated this way. In general, we’ve taken a different approach to these problems, insisting that errors be handled closer to their source.

[

I go to the gym and lift weights because I like the feeling of getting stronger and better. Two months ago, I started to feel a throbbing pain in my knees, yet I continued to go to the gym.

I interviewed Joe Stump, former Digg lead architect, founder of SimpleGeo and now the founder of project management tool Sprintly. We covered how he built software at Digg, how that changed as he transitioned to SimpleGeo, what he’s learned about building and managing software teams, and why he chose Sprintly as his next project to focus on.

The concept of open source has allowed software development to evolve in very different ways than many other industries. It’s common practice for even the largest tech companies to regularly rely on open source software. Even Google relies on open source software to keep running, from using languages like Python to libraries like OpenSSL and OpenSSH.

I’m sure many of you have heard, but Ruby on Rails version 2.3.x is no longer supported by the core Rails development team. This change is going to have drastic consequences for the many organizations still using 2.3.x.

Many of our customers are interested in agile methodologies. Here’s a follow-on to our post about lean software development.

All software has errors. Duh. However, some of them occur more than others.

Lean software development is a movement dedicated to reducing errors and wasted time while maximizing education and efficiency.  Its principles were originally used in IT and manufacturing, and it has since been adopted by the programming community.

Most companies prefer to hire experienced software developers — people who require little training in order to do their jobs. Particularly in startups, even hiring someone at a lower salary doesn’t make sense if that person can’t pull their weight.

The Software Development Life Cycle is a process that ensures good software is built.

Two weeks ago we co-hosted a webinar with Assembla on continuous delivery, and the role of production monitoring in that process.

Production Monitoring: The Key Step Towards Continuous Delivery

This Wednesday at 11am PT / 2pm ET, we’re co-hosting a webinar on continuous delivery with the Assembla team.

Increasing productivity is probably the thing you worry about the most, as a product manager. You have pressures from above, in the form of time and budget constraints, and, if you’re a youthful, optimistic startup, the ever-looming threat of everything just falling apart. Fun.

This is a guest post from Nick Urban. Full bio at the bottom.

If you’re a geek (or a nerd) worth your salt, you’re definitely a fan of xkcd programming comics. The only legitimate reason for not liking it is jealousy that you can never be as clever as Randall Munroe, the genius behind xkcd. And even then, you know you secretly love it. And so, I present, for your reading enjoyment, the definitive collection of the best xkcd comics for programmers.

I talked with  Greg Brockman, one of Stripe’s founding engineers, about how they build software, team management, how to scale a development team and lots more. If you haven’t seen it, check out Greg’s presentation about how Stripe built one of Silicon Valley’s best engineering teams.

Like the Internet itself, 404 pages are kind of in the high school of their existence. Just hear me out. The crusty old 404s of our youth are slowly being replaced by unique error messages custom-built by each website. They’re not just about telling you something’s wrong anymore. Interacting with a website has become a much more holistic experience. They’ve grown up past the basic functionality of an error page into something with personality and a sense of identity. And it’s time to recognize the accomplishment of coming of age.

This week, one of our newer customers (the guys behind Forge) sent in some feedback about how they were loving the Django-Airbrake project for getting Airbrake to play nicely with Django.

It’s been a busy year at Airbrake HQ, the team has been busy working on scaling out the service.  We’ve been doing a ton of work and have been super busy [expect end of year report soon].

For the past month, we ran a swag experiment where we offered a free frisbee to anyone who upgraded or signed up during the month of August.

Today we made the front page of GigOm. We’ve seen great growth in a last few months and completed major backend work on both products. We’ve been building a stable platform that will let us rebuild our notifications,  provide awesome search and a super blazing fast UI.

<img class=“mb-3” src="/blog/airbrake-news/win-a-ticket-to-eurucamp/eurucamp-20121.png “Eurucamp. “"/>

Airbrake is proud to be sponsoring eurucamp 2012. Eurucamp2012 is a community-organised not-for-profit ruby conf with Sessions, Hacking, Siestas and grilling, all on the largest lake in Berlin and we have a FREE ticket! EuruCamp starts on 17 - 19 August 2012.

I was lucky enough to get to meet the Substantial team while in Seattle. It was one of the best designed spaces I’ve been to, with a strong imprint from the Substantial staff. The DJ booth isn’t just for show, 6 of the substantial staff are DJs. There acoustic knowledge helped build an acoustically perfect meeting room; I’m jealous.

This is an invited guest post from Sau Sheong Chang. After meeting Sau we fell in love with his creative love of Ruby and R. We have an exclusive preview of his new book, Exploring Everyday Things with R and Ruby: Learning About Everyday Things [Paperback].

Getting your heart rate using R and Ruby

The heart rate, or the rate at which your heart beats, is one of the measurements you’ve probably heard most about in relation to exercise. It’s also often a good indication of your health, because a heart rate that is too high or low couldindicate an underlying health issue. The heart rate is usually measured in beats per minute (bpm) and varies from 40 to 220 bpm. An average healthy person at rest has a heart rate of 60–90 bpm, while conditioned atheletes have a resting heart rate of 40– 60 bpm.

A popular and fast way to effectively get the heart rate is pulse oximetry. A pulse oximeter is a device placed on a thin part of a person’s body, often a fingertip or earlobe. Light of different wavelengths (usually red and infrared) is then passed through that part of the body to a photodetector. The oximeter works by measuring the amounts of red and infrared light absorbed by the hemoglobin and oxyhemoglobin in the blood to determine how oxygenated the blood is. Because this absorption happens in pulses as the heart pumps oxygenated blood throughout the body, the heart rate can also be determined.

We are not going to build an oximeter, but in this post we’ll use the same concepts used in oximetry to determine the heart rate. We will record a video as we pass light through our finger for a short duration of time. With each beat of the heart, more or less blood flows through our body, including our finger. The blood flowing through our finger will block different amounts of the light accordingly. If we calculate the light intensity of each frame of the video we captured, we can chart the amount of blood flowing through our finger at different points in time, therefore getting the heart rate.

We love sticker mule, but while trying to order some stickers I encountered the default error page. I sent them a quick tweet, and a few weeks later we saw them pop up in the app. We’re really excited to help support Sticker mule  and we HIGHLY recommend using their service. We’ve got a bunch of die-cut stickers, they are both kick-ass and well priced with a fast turn around time.

Wheelmap  is the tenth Airbraker in our “Awesome Airbrakers” series!

We welcome Causes  as the ninth Airbraker in our “Awesome Airbrakers” series.

<img class=“mb-3” src="/blog/awesome-airbrakers/nyc-airbrake-cribs-kickstarter/kickstarter-office-front-door11.jpg “kickstarter-office-front-door”"/>

For the second in our Airbrake Cribs, we were lucky enough to get a tour of the Kickstarter office thanks to Lance @cainlevy.  Kickstarter has been using Airbrake since 2010, and have slowly taken over this East Village office building as Kickstarter grew.

<img class=“mb-3” src="/blog/airbrake-news/scalaz-airbrake-scala-notifier/airbrake-scala1.png “airbrake-scala”"/>

We’re happy to cross post that StackMob has just shared it’s Scala client for Airbrake. It is written in Scala using Scalaz IO and actors. Code found on GitHub here.

<img class=“mb-3” src="/blog/report/krakow-railsberry-airbrake-report/krackow-tram.jpg “krackow-tram”"/>

After leaving San Francisco at 9pm, I finally arrived in Krakow at 11pm the next day.  This was my first trip to Poland, and I was excited to meet the people and take advantage of the strong dollar vs Zloty (the local currency).

<img class=“mb-3” src="/blog/report/krakow-railsberry-airbrake-report/polish-breakfast.jpg “polish-breakfast”"/>

A traditional Polish Breakfast Cheese, Ham, Cucumber, Bread and Fried eggs. This was an excellent way to start a day in Krakow. On my first day, I visited a few Airbrake customers; using the wonders of Intercom, I found 25 users, and after morning coffee I was chilling in their offices. Afterwards I made it to the Railsberry hackathon.

<img class=“mb-3” src="/blog/report/krakow-railsberry-airbrake-report/hackathon.jpg “hackathon”"/>

RailsBerry!

Railsberry is ‘a sweet European Rails Conference’ in Krakow, Poland.  It is put on by the crazy kids at Applicake and they have a passion for unicorns, rainbows, love and rails. It’s a two day conference with an eclectic range of talks.  Talks ranged from crowd funding, ruby project stats, coffeescript, NoSQL databases, and Enterprise SaaS to being a VIM ninja!  All talks were recorded and will be posted online.   My personal favorites were Eric Redmond’s NoSQL talk (as we switch to Riak) , Linda Liuka’s‘Rails Girls’ talk for reminding everyone how awesome rails programming is, and Zach’s insight into rails stats.

There were a few awesome moments, such as 200 ballons going in the air

[video]

, a 7ft unicorn, and some hilarious lighting talks.  I’m going to highlight all the awesomeness in another blog post, with 8 tips to throwing an exceptional conference.

<img class=“mb-3” src="/blog/report/krakow-railsberry-airbrake-report/ballons-1.jpg “ballons”"/>

<img class=“mb-3” src="/blog/awesome-airbrakers/krakow-cribs-cloudvertical-lunar-logic-polska/AirbrakeCribs1.jpg “Airbrake-Cribs-Krakow-Edition”"/>

WAZUP! It’s ya boy 50Cent here for the first Awesome Airbrake Cribs.  This new series  lets us visit and get a sneak peak into the coolest offices, hacker dens and brogrammers bedrooms.  We visited two awesome companies based in Kraków, Poland .

We welcome GrubWithUs  to the eighth Airbraker in our “Awesome Airbrakers” series.

<img class=“mb-3” src="/blog/ios/tracking-ios-errors-with-airbrake-ios-notifier-v3-0/trackios11.jpg “track ios erros with airbrake”"/>

In October of 2011 we bumped the Airbrake notifier for iOS and Mac to version 3.0. This near-complete rewrite of the product fixed a lot of known issues, reduced the number of dependencies, made it easier to install, and simplified the way in which developers interact with it. Since then we have been taking a lot of user feedback as well as contributions to the open source project found on github to fine tune its performance and give developers more control over its behavior.

We welcome Alan from Treehouse to the seventh Airbraker in our “Awesome Airbrakers” series.

<img class=“mb-3” src="/blog/report/pints-with-pusher-airbrake-and-exceptional-london-report/AirbrakeAfterParty1.jpg “Airbrake After Party”"/> <img class=“mb-3” src="/blog/report/pints-with-pusher-airbrake-and-exceptional-london-report/london-rooftoops1.jpg “london-rooftoops”"/>

Pints with Pusher, Airbrake and Exceptional was our second official drinkup.  Close on the news of the acquisition, the event was changed at the last minute to invite all the Exceptional users.

I arrived in London on the day of the event. Being English, and having studied in London it’s always a pleasure. It’s an amazing capital that is constantly changing.

Shoreditch and Old Street are some of my favorite spots. You can’t beat Old Street for an Indian, and you can’t beat Shoreditch for a Vietnamese.  Shoreditch is a  hub of hipsters and startups. Moo and Last.Fm being among the  big hitters.

I spent an afternoon in the Pusher office, which is directly above Last.Fm office. The same office building houses several other startups including our friends at Trigger.io.

<img class=“mb-3” src="/blog/report/pints-with-pusher-airbrake-and-exceptional-london-report/getting-ready1.jpg “getting-ready”"/>

After ‘selling’ 50 invites, we were pretty excited to see who would turn out on a cold Thursday evening.  Lina had sorted out a venue at the Bar Music Hall ; the event went really well with a real cross section of the London developer community. With devs from ThreeDeePixel.co.uk  , Pandastream.com, intercom.io, blackboxav.co.uk, @mitchellcamp, @adamamosdesignr .

Apologies to J. Pablio Fernadez who was turned away, after a mix up at the bar. We will have better signage and make things clearer next time.

Thanks to everyone for turning out. I hope to be back soon.  Report by @benarent. A big thanks to @pusher for organising and splitting the bar tab.

<img class=“mb-3” src="/blog/report/pints-with-pusher-airbrake-and-exceptional-london-report/pusherdrinking1.jpg “pusherdrinking”"/>

Pints and Banter at the Bar Music Hall. The Pusher crew can be spotted on the right.

<img class=“mb-3” src="/blog/report/pints-with-pusher-airbrake-and-exceptional-london-report/AirbrakeAfterPartytwins1.jpg “AirbrakeAfterPartytwins”"/>

Lisa and Mary-Anne are working on a stealth fashion startup. Mary-Anne (right) is a JS ninja!

We welcome Matthew Bostockfrom Wunderkit to be the fifth Airbrake user in our “Awesome Airbrakers” series.

<img class=“mb-3” src="/blog/report/bier-mit-airbrake-berlin-report/itscold1.jpg “itscold”"/> <img class=“mb-3” src="/blog/report/bier-mit-airbrake-berlin-report/gregorjump1.jpg “gregorjump”"/>

We welcome UserVoice to be the fourth Airbrake user in our “Awesome Airbrakers” series.

We welcome Winfield from @patientslikeme to be the third Airbrake user in our “Awesome Airbrakers” series.

We welcome Joe from  @mediapiston to be the second Airbrake user  in our “Awesome Airbrakers” series. Awesome Airbrakers is a series highlighting Airbrake users. We’ll be hand selecting Airbrake users, along with taking submissions.

We welcome @larspind from ZenBilling, to be the first Airbrake user  in our “Awesome Airbrakers” series. Awesome Airbrakers is a series highlighting Airbrake users. We’ll be hand selecting Airbrake users, along with taking submissions. To be featured simply fill this formor contact ben@airbrake.io .