Bogged down with Java errors? This series presents the 50 most common compiler errors and runtime exceptions that Java devs face, and how to conquer them.

In this article, I will discuss all three Artificial Intelligence, Machine Learning, and Deep Learning in detail, along with their examples.

Microservices need a different approach when it comes to testing. The microservices test pyramid is more complex. Here's how to use it.

AWS vs Azure vs GCP - how do these cloud providers compare when it comes to IAM? Read on to find out.

Follow this tutorial to learn how to create a minimal Web API with .NET CLI and Visual Studio 2022 to publish it on Azure Web App and API management.

Which Trends Are Flourishing in Supply Chain Management? All You Need to Know About EDI and API in One Guide - Uses, Differences, Benefits, and Trends Covered.

Enabling Big Data best practices is an important role for both data scientists and data analysts to ensure the smooth running of any organization.

This simple tutorial walks you through how to create a Tetris game with Three.js.

Let's see how to deploy an ECR image-based Lambda onto the AWS Console.

This article explores the differences, trade-offs, and architectures of JMS message brokers and Kafka deployments.

Keep on the lookout for sniffing, framing, and HTTPS Pinning by setting up a proper API gateway.

Percona Product Manager Sergey Pronin demonstrating how to migrate MongoDB to Kubernetes.

Check out the latest trends in mobile app development, including a Swift takeover, enterprise apps, and IoT advancements.

The Internet of Things (IoT) has changed the way the entire world operates.

Groovy Database Can Be a Powerful Tool There are coders all around the world right now working on some of the most challenging coding problems that are out there. They are all likely relying on using Groovy database at least to some extent as this is a major player in the industry. People from all over the world recognize the true power of Groovy database and all that it can provide to them from a coding perspective, but the fact that it is such a powerful tool should not be ignored. If you want to advance very far with Groovy database at all, you will need to make sure you have a firm grasp on what it is and why it is so useful to coders all around the world. How it Compares to Java Most people are familiar with Java and have likely used it in their coding adventures at some point. It is a primary tool that has helped with the coding of numerous projects that you are likely familiar with already. Java is a great place to get started, but it doesn't necessarily compare so well to Groovy when they go head to head. It depends on what you are trying to get done, but the use of Groovy trumps Java for most developers. The reason is that most developers prefer to work with a system that has been specifically created for them. Groovy is that system. Everything that it offers is crafted with the developer in mind, and most agree that it is more user-friendly from a developer's point of view. This means that you don't have to waste your time trying to figure out how to work the very system that you are just trying to make some progress on in the first place. Java users are frequently frustrated by their inability to get as much done as they might like to because they are constantly running into brick walls when it comes to how they develop the systems that they need to develop. Most people significantly prefer it if they are able to cut away everything else and simply get to the root of the problem that they are working on. Then, and only then, can they truly begin to formulate a strategy that will allow them to create something that the world will gravitate towards. I am a big fan of using SQL in java and C# software. I typically dislike the usage of ORM frameworks like Hibernate. I feel that ORMs tend to hide a lot of issues. They also tend to have a higher learning curve. I am not sure that the ROI on deeply learning an ORM is sufficient enough to use. However, there are a lot of pitfalls that come with being so close to the SQL. The largest of which is proper resource handling. If database connections are not closed properly, the application will soon become starved of available connections. This post contains a simple example of using Groovy Categories to help manage the resource management of database connections. There are a lot more robust solutions (ie: GORM), but sometimes you only need a quick implementation. To accomplish our goal, we will be using a static closure defined below. The OpenDatabase class is merely a container for the closure. I think the final implementation of the code reads nicely because of the name. OpenDatabase.groovy import groovy.sql.Sql class OpenDatabase { def static with = { DbConnection conn, Closure closure -> Sql sql try { sql = conn.getConnection() if (closure) { closure(sql) } } finally { sql.close() } } } The DbConnection class is a simple interface for creating the groovy.sql.Sql object. DbConnection.groovy import groovy.sql.Sql; public interface DbConnection { Sql getConnection(); } Below is the sample usage of these two classes. OpenDatabase.with(dbConnector) { sql -> sql.execute("insert into BLAH...") } The database connection will be closed after closure exits. Simple, easy resource handling. The groovy way. The original article can be found at http://www.greenmoonsoftware.com/2014/04/groovy-database-resource-handling/ Applying Mass Data to Problems One of the upsides to Groovy database handling is that you don't always hear about is the fact that you can apply massive amounts of data to the issues that you are attempting to take care of today. The beauty of this is the fact that much of that data will prove very useful to you as you work on trying to figure out exactly what it is that people want from your projects. The more data you have, and the more data that you can apply, the better the outcome will be for yourself and others. Groovy allows you to input all of the data that you require all at once so you aren't constantly left struggling to try to figure out which steps you need to take next and how you will get things done. Simply use Groovy to get the results that you need, and you will be all set. A large amount of data is always preferable to use because it will help you figure out what is truly going on within the scope of what you are working on. Any single piece of data could be an outlier, but when you have a major data dump to go through, you know that you are getting the most relevant information right away. Endless Possibilities Groovy has made it so much easier for developers to work out what they will do to get their code set up just right that it has truly performed an amazing service that we should all be grateful for. This is why we need to note that the possibilities are virtually endless when working with Groovy and the tools that this service has provided. It is a very big deal when you get your code to sync up just perfectly, and that is what you get when you use the Groovy system. There are now so many people working within the system that it has grown much larger than some of its competitors. That is why we anticipate that many interesting developments are going to come out of it. When you have that many people working that hard all within the same system, you are generally going to get some pretty outstanding results to come out of this. You need to account for that fact and understand that there are numerous upsides to using a system that works just like that. A Great Place for Starters Those who are just taking on the coding world for the first time need to look at Groovy as the kind of place where they can start to hone their skills. It is not necessarily the first area that people necessarily think of when they are looking over different coding programs to get started with, but it is where they should begin. The controls are so much more refined for the kind of person who is just getting started, and that means that it is the ideal training ground for someone who is truly eager to learn the system and get to work within it. People who are just starting their coding journey should be excited to have the resources available to them to get started in this way. It can all prove extremely useful in the long run.

Tracking open-source data users is harder than you think, but the Eclipse Foundation is trying to make it happen

I'm Stefano Chiappa and I'm from Milan (Italy). I work at Prisma Engineering (http://www.prisma-eng.com/) as Lead Software Engineer of the Simulator User Interface Team. AirMosaic is an application on the NetBeans Platform for controling Prisma's UeSIM, which is a multi mobile simulator. The UeSIM is basically a server with some antennas able to connect to a base station and simulate a population of mobiles doing some basic or complex Test Procedures. These procedures can be "real-world" applications such as HTTP, FTP, Mail, VOIP calls or protocol-dependent procedures such as attachment/detachment to the Core Network. Several mobile technologies are supported: LTE/UMTS/GSM. The images below are taken from LTE version. Why VoIP calls are more popular than ever The AirMosaic technology that is used within the Netbeans system is something that is generating a lot of buzz and helping companies get work done that they must surely have believed would take much longer than it has. One area that AirMosaic has come into play very rapidly is in the realm of VoIP calls. VoIP stands for "Voice over Internet Provider", and this refers to the way that many calls are received in the modern office environment these days. A few reasons why office managers prefer VoIP over other options is because: Prices are lower - Generally speaking, the cost of VoIP calls are lower in total. You don't have to pay some of the additional costs that come with international calls or other types of calls when using a VoIP system. Instead, you receive a lower overall cost because the cost is usually a standard and flat rate. VoIP meshes well with existing and emerging technology - VoIP works well with both existing technologies as well as those that are emerging on the scene at this time. Thus, office managers and anyone else who is involved in the phone purchasing process for an office will often find VoIP causes them the fewest headaches as far as combining it with what they already have or what is soon coming down the line. Excellent call quality - It is hard to beat the call quality that you receive with a VoIP system. The calls are crisper, clearer, and provide the consistency that every office is looking for. You really can't go wrong with a VoIP system like this. In the first step a population of mobiles is created. It is possible to edit a huge amount of parameters related to the mobile device hardware and the user subscription related to the SIM. The following image shows the editing of this mobile database, which is performed inside a NetBeans editor and properties window (click to enlarge the images): Once a Mobile population has been created, it is possible to create a scenario (navigator window) where is described what a single or group of mobiles will do. The available test procedures are collected and grouped inside a navigator window on the left bottom side, where you can see some of the available tests: When the scenario has been created, it is possible run it through the UeSIM hardware. This is displayed in the next image: On the upper left side of the image, AirMosaic displays, through some gears, the currently running test. We used a central editor window to display some counters of the running simulation. It is possible to choose the displayed counters by checking a node of the tree on the left side of the window. On the lower side of the application, there is an output window that displays the sequence of events happening during the simulation. Once a scenario has been completed, the scenario window, on the application's top left, shows a green circle to indicate that the test has been completed successfully, as you can see in the next image: Some plots can be drawn for each counter available. It is possible to put different counters on the same plot or on different plots. This is displayed in the next image: At the end of a test, it is possible to generate a report, save it as a PDF, or send it by mail automatically, as shown in image below: This is basically what the application does. Several features are still in development, of course! AirMosaic Runs Simulations For Phone Testing Purposes Did you know that it is important to test the phone systems within your office on a regular basis? You should do so not only because you need to make sure the phones are working so that customers can call in, but also to make sure there aren't any fraudsters trying to take advantage of a vulnerable phone system. Believe it or not, there are fraud cases in which the criminals will attack a phone system set up by a company for their own malicious purposes. Fraudulent calls can ring up huge expenses for companies that are difficult to repay. Obviously, this is not an ideal situation for anyone, and it is best to avoid such scenarios by testing the phones on a regular basis to make sure that there isn't anyone in the system who shouldn't be there. AirMosaic can run sweeping tests of phone systems to try to detect problems like this. What AirMosaic will do is run their sweeping tests to detect any anomalies within the system and alert you to what is going on. They will even let you know if there are phone calls within the system being placed by people who work for you that shouldn't be placed. It would be incredibly challenging to run all of these tests by yourself, and that is why so many are using AirMosaic instead. They see the value of adding a little extra security to their phone systems, and they realize that the only true way to do so is to run a program like this that can detect any problems. Data is Generated That Can be Scanned Finally, AirMosaic produces a list of data on the phones that it has scanned which you can view on your own time. Look over every piece of information that the system found in order to figure out what is going on with the phones that it has identified as perhaps having a problem. AirMosaic is very good at narrowing down the list for you so you don't waste your time trying to go through all of this information on your own. Instead, you rely on AirMosaic to help you out, and then you simply review the data that it discovered in order to get a better idea of what may be happening within your system. By isolating the phones that appear to have a problem, the AirMosaic system makes it easier for you to see which specific phones you will look at and why they may be having some issues. Users sincerely appreciate this because it means that they can finally receive the data that they require to send in their team of IT experts to fix the problem. It takes a little bit of time and effort, but it is worth the trouble when you identify the problem and get people involved who can help. Save your company from the risk of being vulnerable to attack over the phone system. Use AirMosaic to run some tests today.

Cloud backup is more important than ever, and it needs to be respected and understood.

Released back in 2012, Neo4j 1.8.M03 introduced the RELATE clause, a two-step dance of MATCH or CREATE. Also, new Transaction support in the shell lets you call for a do-over in case you misstep. RELATE, a Subgraph Match-Maker A RELATE clause looks a lot like a MATCH clause — the ASCII-art of graph traversals — but behaves differently when there isn't a satisfying subgraph. When there is no match, RELATE will create the needed Relationships and even intervening Nodes. RELATE ensures that the subgraph exists. So, I just fetched myself a coffee. Let's say I want to keep track of how often I visit 3 Bees Coffee. I could carve notches on my desk, but I've already ruined one Ikea desk that way. Being graph-minded, I immediately realize that I'll be curious about deeper questions regarding all the places I visit. I will, of course, evolve a graph mini-app. Neo4j 1.8.M01 introduced the CREATE clause, so I'll create me and the coffee shop: CREATE me = {name:"Andreas"}, `3bees` = {name: "3 Bees Coffee"} (Note the back ticks around 3bees because the term starts with a number) To record that I have visited 3 Bees Coffee, I could add a relationship at the same time: CREATE me = {name:"Andreas"}, `3bees` = {name: "3 Bees Coffee"}, me-[:VISITS]->`3bees` Of course, I will be re-visiting coffee shops more often than going to newly opened shops. I already know about me, and will usually know about the coffee shop, so what I really want to do is just create the Relationship. START me=node(1), coffee=node(2) CREATE me-[:VISITS]-coffee Easy as pie. Mmm pie. Create a record for me, create a record for a shop, and whenever I visit a shop, create a Relationship. Because I want to keep track of the frequency of my visits, I suddenly have a problem: I don't want to create a Relationship every time, but get one if it exists and just update a property on it. Cypher is declarative. There is no spoon, I mean 'IF'. So we turn to our friendly match-making RELATE clause: START me=node(1), coffee=node(2) RELATE me-[v:VISITS]-coffee return v That'll match the VISITS if it exists, or create one if it doesn't. To update the visits, I can convert the RETURN into a WITH to tack on a SET clause like so: START me=node(1), coffee=node(2) RELATE me-[v:VISITS]-coffee WITH v SET v.visits=(v.visits +1) RETURN v OK, one last detail to adjust: the classic initial condition problem. If RELATE happened to create a new Relationship, it won't yet have a visits Property. We'll use COALESCE to ignore v.visits if it is null, then add 1: START me=node(1), coffee=node(3) RELATE me-[v:VISITS]-coffee WITH v SET v.visits=(coalesce(v.visits?,0)+1) return v Ah, now I have even more motivation to take coffee breaks. The RELATE clause is powerful fun. Get yourself a cup of coffee, then sit down to peruse the Neo4j Manual section on Cypher RELATE to learn more. And, check on my coffee consumption in the Neo4j Live console, where you can play around with RELATE. Transactional Shell Prior to this release, every query issued in the Neo4j shell (whether command-line or in Webadmin) created a transaction when needed. Now, you have control over transactions with some new shell commands: begin transaction, commit, and rollback. These let you practice your new Cypher dance moves without worrying about falling on your face and taking your database down with you. As usual, look to the Neo4j Manual for the details. Now that we’ve looked back in time, let’s see what Neo4j can do better than SQL. SQL is an impressive query language but there are things that Cypher handles so much better. Whereas SQL started as a single table query language, support was added later for geospatial data and for XML and JSON as well. XML is primarily used for displaying documents on web pages. It uses customized markup languages that are user-defined. JSON reads data from web servers in order to display it online. When dealing with relational databases which are built on tables, JOINs make the connections. So how does this relate to Neo4j? Well, Neo4j is designed to handle product recommendation engines as well as supply management and personalizing customer experience. And Cypher’s graph query language allows you to extract data from graphs. It’s essentially SQL for graphs. Cypher is easy to use and understand. It’s designed for graphs. It borrows from other languages such as Python and is a powerful, full-featured modern language perfect for data analysts and subject matter experts who need to extract meaningful data by reading and writing queries themselves if need be. You don’t need to be a developer to get the benefits from Cypher. A feature of graph databases is that their searches are schema-free. Or at least optional. By not having a fixed schema you can develop the relationships, add attribute types and develop your data as you go. This provides extreme levels of flexibility when developing applications. SQL Path Patterns Query Using path patterns which is an advanced feature, you can have a product that points to a list of categories. With a deep hierarchy, one which you don’t know the depth of yet, you can insert a “*” to find arbitrary linked relationships right to the root directory. But you can limit it to a set number of relationships as well as categories. This is all easily achieved in Cypher but requires linking together a chain of queries in SQL. Each level must be spelled out in the query to the limit that is needed. A cumbersome and time-intensive process, especially when you don’t necessarily know how many categories you’re going to end up with anyway. Find All Cycles in a Directed Graph If you wish to find loops, where a loop leads back to the same person or thing over again, path patterns will determine the outcome. Using MATCH path = (p:Person)-[*3..10]-(p), one can look for 5 hops ending with the person you started with. Not only is the data available in a table but it can be generated visually. And that in essence is what you get with Cypher; a powerful much more user-friendly tool that is purpose-built to provide graph queries in a format that the user can manipulate to show relationships without being bogged down in endless hours of programming and validation. Combine Reads and Writes If you’re familiar with SQL, you need to support Reads and Writes by using insert statements or insert from select. Unfortunately, that’s where it ends. Cypher does the heavy lifting and combines reads and writes in a single query. So, you can update the database while simultaneously fetching data. The benefits of Cypher over SQL don’t end there but I’m sure you get the point. Relate Yourself Neo4j 1.8.M03 is available for immediate download in the usual places. Get it now: Download from neo4j.org Bump the versions in your maven pom.xml Provision on heroku with: heroku addons:add neo4j --neo4j-version 1.8.M03 Want to practice Cypher with fellow Graphistas? Join us at a meetup somewhere in the world, or propose a new location and we'll look into visiting your area to buy you a cup of coffee. The content of this article was originally written by Andreas Kolleger over at the Neo4j blog.

While a lot of databases have been created listing information in a table format, the web isn't set up in a tabular style. Neither is plenty of data in a variety of formats that the web uses. However, many databases are still using tables, because many web developers feel that tables handle plenty of data better than any other structure. Others feel that the data tables known as RDB should be converted to RDF, a format used to gather an even wider array of metadata across the worldwide web. The ability to convert to RDF will be extremely beneficial as technology advances to Artificial Intelligence AI and beyond. What is an RDB? RDB stands for a Relational Database. An RDB is a collective set of multiple data sets organized by tables, columns, or records. An RDB establishes a well-defined relationship between database tables. The tables communicate to share information that makes it possible to search for data, organize, and report. RDB is derived from the mathematical function concept of mapping data sets as developed by Edgar R. Codd. RDBs use Structured Query Language, SQL.SQL is a standard user application that provides an easy programming interface for database interaction. RDBs organize data with each table known as a relation which contains columns. Each table row, or record, contains a unique data instance defined for a corresponding column category. The data and record characteristics relate to at least one record to form functional dependencies. RDB performs "select", "project" and "join" database operations, where select is used for data retrieval, identifying data attributes, and combining relations. Those who prefer to use RDBs do so because of the advantages, including easy extensibility or scalability, new technology performance, and data security. What is RDF? RDF is primarily used to provide information or metadata for data available on the Internet. RDF provides the methodology for specifying, structuring, and transferring metadata, and provides the basic XML syntax for software applications to exchange or use that information. The URI/URL provides the location of that data. RDF stands for Resource Description Framework and is a standard for describing web resources and data interchange, developed and standardized by the World Wide Web Consortium, W3C with Xtensible Markup Language (XML) and Uniform Resource Identifier (URI) serving as its distribution standards. Typically, RDF provides basic information and attributes about an Internet-based object, such as the name of the author, Web page keywords, object creation or editing data, or the sitemap. While there are many conventional tools for dealing with data and more specifically for dealing with the relationships between data, RDF is the easiest, most expressive, and most powerful standard to date. The overall informational value is much greater because context or intent can be inferred. RDF presents small chunks of information in a form that infers meaning. This can include rules about how the data should be interpreted. Resource Description Framework, RDF, is the standard for encoding metadata and other structured information on the Semantic Web. Semanticization Data With all the semantic standards and database-centered HTML5 APIs and a W3C standard that calls for implementations, this is an exciting time for data on the web. It's time to embrace RDF with the capacity to start pulling relational data into the semantic web! The Purpose of RDBMS The software used to store, manage, query, and retrieve data stored in a relational database is called a Relational Database Management System, or RDBMS. The RDBMS provides an interface between users and applications with the database. It also provides administrative functions for managing data storage, performance, and access. Semanticization, or giving meaning to, all data can be done in two stages. First, construct a web of meanings, not documents -- as Sir Tim Berners-Lee has always wanted, and as the RDF, Resource Description Framework seeks to do. Second, fit all tabular data into the web whether legitimately or not. This second step is less exciting than the first because plenty of tabular data is not ideally tabular. In these cases, the second step is rather backward-looking. However, it is no less necessary than the first for two reasons: Converting everything RDBMS to RDF is not even close to worth it Much data ought not to be converted to RDF All of this data still needs to talk to the web, which means it needs to be translated into a webby structure, ideally RDF. The easiest way to translate without conversion is, of course, just plain mapping. But mapping two rather different structures to one another is no small undertaking or trivial task. That's why there's a whole W3C Working Group devoted to devising a mapping language and actual mapping of relational data to RDF. Sir Tim offers this insight into the RDF-RDBMS relation, cutting through questions that might otherwise be couched in domain-inappropriate terms (like 'is the RDF model an entity-relationship model'): Relational database systems manage RDF data, but in a specialized way. In a table, there are many records with the same set of properties. An individual cell (which corresponds to an RDF property) is not often thought of on its own. SQL queries can join tables and extract data from tables, and the result is generally a table. So, the practical use for which RDB software is used is typically optimized for doing operations with a small number of tables, some of which may have a large number of elements. Because relational databases are species of the genus described by RDF, the basic mapping model is as follows: a record is an RDF node; the field (column) name is RDF propertyType; and the record field (table cell) is a value. So far, so straightforward. Of course, the implementations usually wander pretty far from the original concept. That's why mapping actual RDBMS to RDF takes a bit of dirty work. RDB2RDF Enter RDB2RDF. The RDB2RDF WG is doing the dirty work. Back in 2005, when the Group was still an Incubator, they published a detailed survey of then-current approaches to mapping relational databases to RDF. This survey served as the starting point for typically extensive discussion and debate, which culminated in two Candidate Recommendations: The RDB to RDF mapping language: R2RML The Relational-to-RDF mapping itself Many techniques and tools have been proposed to enable the publication of relational data on the web in RDF. RDB-to-RDF methods are one of the keys to populating the web of data by unlocking the huge amount of data stored in relational databases. Since producing RDF data with sufficiently rich semantics is often important in order to make the data usable, interoperable and linkable, there are various strategies developed to enrich data semantics. Turning RDB to RDF has proven to be of value when dealing with SQL databases. It offers a straightforward and practical system for relational database conversion into RDF. RDB2RDF and the Future Moving forward beyond RDB-to-RDF methods, it will become necessary to find a compromise between the expressiveness of RDB to RDF mapping languages and the need for updating relational data using protocols of the semantic web. Creating, updating, and deleting RDF data should only be made possible in a secure, reliable, trustworthy, and scalable way.