Learn how to use a Python AWS CDK application to configure and deploy your Apache Airflow environments using MWAA in a repeatable and consistent way.

Your git fairy godmother will test and locate the bugs for you with a swish of her magic wand. All you need to know are the magic words: git bisect.

Connecting to Jira in Python.

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.

Images Add to the Experience Adding images to something that you are working on in the Windows 7 phone can be a great way to appeal to people in a more full way. This is to say that many users of your programs and services will expect to see images contained within. Humans are a visual species, and it is always nice when the tools that we use provide us with the images that we have come to expect from the services that we use. Any app developer for Windows 7 phones (or any other type of phone for that matter) understands that they need to use the tools at their disposal to put some images together in their apps. Not only are images nice to look at, but they can help convey certain messages that need to get across to people who are using the app as well. This is a big deal for many because they will understand that the images bring in more and more users. Images are one thing that is quite interesting to work within a Windows Phone 7 application. In fact, for some specific applications manipulating image files can be a necessity (for example, when the application saves and loads edited photos). As you probably already know, the files that are created by a Windows Phone 7 application are stored inside the isolated storage – a storage unit designated for the current application that no other application can access. Unlike regular text files that can be read as plain string units, images are handled in a different way. Even if you used Silverlight before, opening image files in a Windows Phone 7 application will require you to use a different approach, since you won’t be directly in control of the storage space. Basically, saving an image locally (for example, from a web site) is quite easy. If you’ve read my previous article on file handling , then I can say that the same principles are applied here. To show an example, I am going to use a WebClient to download an image and store it locally. WebClient client = new WebClient(); client.OpenReadCompleted += new OpenReadCompletedEventHandler(client_OpenReadCompleted); I am referencing the OpenReadCompleted event handler that will be triggered when the data from the specified resource will be completely cached. Therefore, all I will have to do is store it for permanent access. Here is how the actual event handler looks like: void client_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e) { var resInfo = new StreamResourceInfo(e.Result, null); var reader = new StreamReader(resInfo.Stream); byte[] contents; using (BinaryReader bReader = new BinaryReader(reader.BaseStream)) { contents = bReader.ReadBytes((int)reader.BaseStream.Length); } IsolatedStorageFileStream stream = file.CreateFile("file.jpg"); stream.Write(contents, 0, contents.Length); stream.Close(); } This way, I am converting the downloaded stream to a byte array and I am storing it in the root folder as a JPEG image. The actual image download is triggered via OpenReadAsync: client.OpenReadAsync(new Uri("http://www.google.com/images/srpr/nav_logo14.png")); Here I am passing a sample image URL (feel free to change it to whatever image you want). So it is downloaded and stored. Now it’s time to read the contents. To test this, I inserted an Image control on the page that will display the stored image. To retrieve the image, an instance of IsolatedStorageFileStream is used: IsolatedStorageFileStream stream = new IsolatedStorageFileStream("filet.jpg", FileMode.Open, file); var image = new BitmapImage(); image.SetSource(stream); image1.Source = image; Although the first thing that comes to mind would be using a relative URI for the image source, it will not work on a Windows Phone 7 application because the user has no direct control over the storage unit. Making Sure Your Images Work Properly Here is another thing that you don't always necessarily learn until you have some coding experience under your belt. It is that not all images are properly formatted when you are first starting out. You need to make sure you get the formatting down pat just right so your images will appear on screen as you desire for them to do. In other words, don't take a chance with getting a blurry image or an image that won't load on any project that you are working on. Sadly, this kind of thing happens to people sometimes, and the results can be less than desirable. To avoid the problem of potentially getting your images out of line, make sure you carefully look at how you format your images and ensure that the code is all set up properly. You don't want to put something out there with images that are off-kilter. If you do so, you may get backlash from your users right away. They will make it clear that you should not have done something like that, and they will ultimately revolt against what you have created for them. Don't take a chance like that when you don't have to. Only Use Images That You are Permitted to Use Most images on the Internet have some kind of copyright or attribution to them. You can't simply take them and use them for your own creations. If you do so, you are stealing someone else's work, and it is a very big deal. Instead, make sure you only look to resources that you are legally allowed to use in order to get the images that you require. There is nothing wrong with turning towards resources that are free and available for anyone to use. People use royalty-free images in their work all the time. In fact, it is a great way to ensure that your work remains safe and legally permitted. The other option that you have is to pay for the copyright usage of the image that you want to work with. There are many photographers who will agree to license their image for you to use if you pay a certain fee to them for doing so. In most cases, the fee is just a few dollars to use their image. It may be significantly more for particularly popular images, so this is something that you must think about as well. Regardless, you may still decide that this is worthwhile to you if you come to find that the images that they have taken are images that you simply cannot live without. Update Your Images Regularly Images can become less relevant over time. One way to avoid having images that are of no use to you is to make sure you are constantly updating your images so they don't go stale on you. When you are an Internet user and you see a website that has clearly not updated its images in a long time, then you ultimately may determine that this is not the kind of website that you want to spend much time with at all. It is understandable that you may come to this conclusion, and that is why developers need to update their images regularly to keep everything fresh and interesting for their users. If you do this, you will avoid the risk of losing traffic because people are less than impressed by the images that you use for the work that you do. Make this a top priority for your creations today.

What I really wanted to do was set a breakpoint and examine the state of the objects at runtime.

This article was originally published on January 1, 2009. Java Just Got a Little Better Have you been struggling to use the Java system as it exists today? If so, don't worry, you are not alone. There are plenty of people going through the same troubles, and no one is pleased with the fact that they have to struggle as hard as they do just to get some simple code put out into the world. Unfortunately, that is the position that many find themselves in today. Java is finally starting to make some much-needed improvements, and people are clamoring to learn more about this service as they view it as a way to get their code out. The newest thing to come to Java that can add a lot of value for developers is RESTEasy 1.0. Easier to Transfer Creations to Apps There have been many complaints thrown at Java about how the data that is created within their system is not exactly easy to get transferred over to the apps that developers tend to want to put that data in. You can probably imagine how this could end up becoming a serious problem. Users are expecting the things that developers create to come out in app form these days, and if they are not provided with this accessibility, then they may be less than satisfied with the ultimate results that they get. Many people feel challenged to get their information and data over to apps so that customers will be pleased with the creations that they have come up with, and that is all fine and good, but it is not always easy to pull off in the Java platform. This is exactly why so many are excited to hear that RESTEasy 1.0 is on the way. RESTEasy 1.0 is literally living up to its name by giving users the chance to rest easily so that they will be able to get their data moved over to apps or anywhere else that they need it to go. There is no more waiting around wishing that you could get this done, it is now much more seamless than ever before. Integrates With Other Coding Tools We all know that some coding tools are built in such a way that they are separate from the other tools on the market. The creators of such tools sometimes think that it is a good idea to try to protect their intellectual property in this way. That may sound fine on paper, but the problem is that it makes their tools less valuable to users. They aren't able to use those same tools with the other coding tools that they are already using, and this can become a big issue for many developers. Needless to say, most people are not that into the idea of using coding tools that won't bring them the value that they have come to expect. As such, it makes sense that coders are now looking at what they can do to get their coding tools to better integrate with the other tools that they are already using. RESTEasy 1.0 is a great system because it doesn't try to shelter itself off in a corner somewhere. Instead, users are able to enjoy the full slate of benefits that this program can provide right from the start. You have many options when it comes to the tools that you use to code your various projects, and you don't want to limit yourself simply because some tools are not as responsive to your needs as others. You should always be able to work with the tools that you have at your disposal to get things done properly and right from the start. I am pleased to announce the first GA release of JBoss RESTEasy. All documentation and download links are available at RESTEasy's JBoss.org project page. JBoss RESTEasy is a framework that allows you to write RESTFul Web Services in Java. It is a fully certified and portable implementation of JAX-RS specification. JAX-RS is a new JCP specification that provides a Java API for RESTful Web Services over the HTTP protocol. RESTEasy can run in any Servlet container, but tighter integration with the JBoss Application Server is also available to make the user experience nicer in that environment. While JAX-RS is only a server-side specification, RESTEasy has innovated to bring JAX-RS to the client through the RESTEasy JAX-RS Client Framework. This client-side framework allows you to map outgoing HTTP requests to remote servers using JAX-RS annotations and interface proxies. Features Fully certified JAX-RS implementation Portable to any app-server/Tomcat that runs on JDK 5 or higher Embeddable server implementation for junit testing Rich set of providers for: XML, JSON, YAML, Fastinfoset, Atom, etc. JAXB marshalling into XML, JSON, Fastinfoset, and Atom as well as wrappers for arrays, lists, and sets of JAXB Objects. Asynchronous HTTP (Comet) abstractions for JBoss Web, Tomcat 6, and Servlet 3.0 EJB, Spring, and Spring MVC integration Client framework that leverages JAX-RS annotations so that you can write HTTP clients easily (JAX-RS only defines server bindings) Special thanks goes to all our independent contributors, specifically: Solomon Duskis, Ryan McDonough, Olivier Brand, Martin Algesten, Michael Brackx, and Justin Edelson. See also: Introduction to REST Putting Java to REST Enter The JBoss Matrix Constant Updates Another thing that needs to be celebrated about the release of RESTEasy 1.0 is the fact that it will be constantly updated and maintained behind the scenes. There are entire armies of engineers working to make sure this program stays up and running properly for its users at all times. This should give users confidence that they will be able to get everything they need out of it right when they need it. No more waiting around just hoping that your program will be updated. You know for sure that RESTEasy 1.0 has people working on it all the time. There are plenty of things that you can do to put yourself in a better position as far as the way you are coding and getting things taken care of. If you would like to, you can start working with the RESTEasy 1.0 system today to make sure you never again find yourself in a situation where you are dealing with potentially faulty coding software. This stuff is the best. Create Your Masterpiece One final note on RESTEasy 1.0 is the fact that you can get to work creating your masterpiece right away. You don't need to wait for anyone to give you permission to start getting work done. Instead, this user-friendly program is great for creating your next masterpiece in the coding world, and you should make sure you are taking full advantage of the opportunities that are presented to you in this way. Create a one-of-a-kind masterpiece that is top-notch and produces something that your users will never be able to forget. You can get started right now when you incorporate the RESTEasy 1.0 system into your next project. It is something that you need to get working for you right now. Make sure you take advantage of all that it can offer you today.

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.

Java is changing the world around us in major ways. Here is how.

A View of Different Pages If you are a Windows 7 phone owner, you may have noticed that your phone has different pages that you can engage with. This is intentional, of course, and allows for users of this phone to get access to exactly the information that they want at any time. Developers look at this as somewhat of a challenge. They need to figure out how they can keep certain bits of information from page to page while transferring other bits, and it is all about what they think their users will need to see from page to page. We have to admit that nothing about this is easy. There are many people who simply won't have the bandwidth or ability to get it all done. That said, it can be very rewarding for some people as they pull off the seemingly impossible. There are a lot of ways to look at the work that creators on the Windows 7 phone do, but few can argue that there aren't some amazing things happening on the system. Another appropriate way for passing data from one page to another during the navigation is in setting up destination page properties (or variables) within the OnNavigatedFrom method of the source page. OnNavigatedFrom method is called just before a page is no longer the active page in a frame. For example this method is called if you invoke NavigationService.Navigate method from a source page. Due to the fact that OnNavigatedFrom method accepts NavigationEventArgs as input parameter you have access to the destination page stored in Content property. Sample I have created two pages: Page1.xaml and Page2.xaml. Inside Page2 I have added a string property named Parameter. Inside Page1 (codebehind) I have overridden method OnNavigatedFrom for setting up Page2′s Parameter property. protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e) { Page2 page2Instance = e.Content as Page2; if (page2Instance != null) { page2Instance.Parameter = "value"; } } Advantages Probably one of advantages is that you don’t have to store values in a static context, but simply pass them from one page to another. That approach is great for a wizard when you have several pages in a row and you need to store only the final result after the wizard is completed. Disadvantages This approach cannot be applied to applications that can lose sensitive information during the suspend mode (Tombstoning), because when the system restores your application from suspend mode there is no way to call OnNavigatedFrom method to set destination page properties. Changing the Default Home Page The default home page that one has set on their Windows phone can be changed as necessary. Some people simply leave up the page that is already pre-set as the default when they get the phone out of the box, but not everyone wants to leave it on that. If there is a page that you are more likely to jump to in the first place, then you need to consider getting that set up as your homepage instead of leaving it as-is. There are plenty of people who make the choice to switch it up like this, and there is nothing wrong with making that same choice for yourself as well. Just make sure you know which page you want to get set up when you do so. Allow For Magnifying of the Page Coders should be careful to make sure they allow users to work within the system to make alterations to the code that they have put out. This may mean allowing them to modify certain aspects of the page in order to make it more useful to them. For example, it might be necessary to magnify the page in order to better see the text that is present on the screen. It is a big deal for some users as they try to read everything that is typed out on the page. These are seemingly small things, but certain users will benefit greatly from the small modifications that they need to make in order to get everything just the way that they need it. Adding Some Shortcuts There are shortcuts that can help people get where they need to go without your app more easily. This will save them some time as they work through the ways that they are ultimately going to use your app. It makes a big difference, and it may save them mere seconds, but that is precious time on the Internet. You need to make sure the shortcuts that you program into your app are done in such a way that makes sense for how it is supposed to operate. The shortcuts should help people get to the most important information within the app. Those shortcuts simply make it easier for people to get to the most important aspects of the app more quickly. There isn't exactly a science to how you create your shortcuts. Rather, you should review the areas in your app that people seem to travel to the most. Those are the hotspots that you absolutely want to have shortcuts ready to go to. People appreciate when the app developers behind their favorite apps have clearly examined their behavior and determined what they are most likely going to want out of the experience. When they see the shortcuts pop up that are obviously useful to them, they know that the developers have done their job properly. Create Real Value Everything that you add into the code of your app should create real value for the users. What does this mean? It means that there shouldn't be any aspect of your app that doesn't add something interesting to what you are doing for the people. The more that you can add to the value that they get out of the app, the better. They are expecting you to really come through for them, and you need to show that you are listening. The information that you place into your app is meant to be used by people for various aspects of their day-to-day life. Are you actually coming through for them and creating something that will enhance their ability to get things done or not? If not, then you need to go back to the drawing board and make sure you are putting your efforts where they need to be put. You risk destroying the trust between yourself and the users of your app if you aren't going the extra mile to deliver something interesting to them. Keep Pages Simple Finally, you should try to keep pages as simple as possible. You don't want to have too many distractions on your page because it will only deter people from using your service. The simpler the pages, the better they are for users. It is a fact that they like to keep things simple because it means that they can just get at the information that matters the most to them. If you make things overly complicated or add in too many bells and whistles, many users are going to get lost in the page. Try to keep it simple and straightforward in order to make it the best possible experience for your users every time. That is all that there is to making an experience that works for everyone.

This article was originally published on February 5, 2008. When a new piece of coding material comes out, the entire coding community tends to get pretty excited about it. They care because they know that it means that there are new applications that they can play around with, and it is entirely possible that there will be some incredible new creations that come out of all of this as well. Thus, there has been a lot of buzz around the Grails 1.0 release, and we are so excited to share with you some of the reasons why this is exciting. Web Development Is More Complicated Than It Needs To Be One universal truth about website development as it stands today is the fact that it is more complex than it honestly needs to be. There are many tools that one may use to work their way through some of it, but few things simplify it down enough for the average person to hop on and feel good about what they are creating. People will tell you that they feel shaky at best about their creations, and that is really saying something. Java is what most people use when they are coding, and it is likely to remain the dominant player for a very long time to come. That said, there are tools like Grail 1.0 that seek to help users get a better sense of what is going on within the coding that they are doing. The hope is that by explaining what is happening, users of Grail 1.0 can get a firmer grip on the concepts that they are working with. What Makes Grail Different? There are plenty of coding languages out there, so what makes Grail so different, and why should people honestly care about it at all? It turns out that the main reason we need to care about it is that it works with Java and leverages Spring to make things even more straightforward and easy to understand. Grail has typically been used for web applications in the past, but the role that it has is now expanding to desktop applications as well. There are different types of people looking to access it at this time, and it seems that allowing them to view it over as wide of a scope as possible is a great way to make sure everyone gets a crack at it even if they don't yet realize that this is something that they want in their lives. Is Grail Catching On? You could say that Grail 1.0 has made quite the splash in the coding community. This is not just some niche product. The makers of this program anticipate that they will see between 5,000 to 10,000 downloads of it per month as it gets kicked off. That is a lot of interest to be circulating around a single product in the coding world. It means that they are expecting an explosion of users to want to hop on and check out what it is all about. If they are right in their projects, then this download could prove to be something very big indeed. It may even become a must-have product in coding. When you have something that catches on with that big of a segment of the population, it is often the case that it has struck some kind of chord with them, and it means that there is a lot to be excited about on the product development side. It is a huge deal that things have gotten as far as they have, and we must recognize that there is still room to grow this project out even more, but it is exciting that it is doing as well as it is already. Graeme Rocher just announced on the Grails mailing list the release of Grails 1.0. I'm very happy to announce this news here on Groovy Zone since more than 2 years ago I stood at the cradle of Grails together with Graeme, Guillaume La Forge and Dierk Koenig. Grails, Groovy and the entire Java community has gone a long way since then. Grails has seen the rise of many competitors since its inception. JRuby on Rails has become a reality. Seam is going strong. Yet the popularity of Groovy and Grails is undeniable, as the traffic on Groovy Zone indicates. Thanks to the Grails development team for all the hard work. Grails went through quite a few refactorings. Out of this came ExpandoMetaClass which helped to re-write the Meta-Object Protocol in Groovy 1.5. I also like BeanBuilder, a Groovy builder for configuring a Spring ApplicationContext. For me Grails is the ultimate rapid prototyping platform for Java. I've built numerous applications by dropping in existing Hibernate-configured classes and generating scaffolding views. It gets you started really quickly and helps you to focus on the application you're building. GSP and the Grails tag libraries are amazing, they're so much better than JSP tags. And let's not forget the numerous Grails plugins. The Search plugin is terrific, it instantly adds search functionality to your application. Check out all the Grails plugins for your needs. Download Grails 1.0 here. Read the user guide here. Watch the screen casts here. Check out the Grails and Groovy books here. An Open Source Product As with many things these days, Grail 1.0 is an open-source product. That is a huge deal simply for the fact that it means that you can access the Grail 1.0 program that you need without having to pay a penny for it. It also means that people are constantly adding more features to the program as time goes on. You will want to check in on this regularly because it means that there may be some interesting updates that are added to it from time to time. You certainly don't want to let those pass you by. There is a whole world of developers out there who are adding their own personal touches to projects like this. You will discover that many of them are extremely well-versed and great at what they do. You may even learn a thing or two about how you need to structure your own coding projects in the future. There may be some critical information that you learn from other coders and discover that you can tweak your own codes to make them even more functional. Add it to Your List of Tools You may love Grail 1.0, or you may feel more uncertain about it. At the end of the day, it doesn't matter all that much. What is ultimately important is if you can use it as part of your overall routine for getting more information out into the world. You likely have tools that can help the rest of humanity, and you need to just add it to the other tools that you have for coding. It might come in handy someday, and it is unclear when that day will be. Think about this and make sure you throw it in there with everything else that you have going for you. It could prove to be extremely useful at some point in time.

Automated deployment doesn't have to be difficult. Learn how to use the Mule management console and Maven to achieve automated deployment.

Working With ListViews in Android Development Putting up a list of elements that people can see and work with is a very common tactic when working on mobile applications. It is something that developers are called upon to do all the time, and it is a good thing we have them working on these things because otherwise the apps that we all use on a regular basis simply wouldn't hold up to the workout that we put them through when using them. That is to say that they wouldn't look nearly as good as we are used to them looking at this point. Most developers will look at ListView in Android at some point in their developing career. It is a typical thing for developers to do, and you might as well get used to using this application if you intend on working in the field for very long. It will come to be expected of you. A Full View Of Information A primary reason to use ListViewer when developing a new app is simply to allow users of that app to see everything that they need to see as they are scrolling through it. They may want to spend some extra time on certain elements of what you have created, and that is all possible when you provide them with the list or "table of contents" for your application. You may be surprised to learn just how much people appreciate this and how much it truly benefits them. Funny as it might sound, these are the types of things that make a difference in the lives of people who are just trying to figure out what kind of apps they will use. The ListViewer app allows developers to provide their users with precisely what they are looking for as far as the information they need to access right when they need to access it. No more hunting around trying to find a specific aspect of the app that you are currently using. It is all right there when the developer has taken the time to use ListViewer to make it easier to scan. Accessibility is the Name of the Game Have you ever used an app that you weren't quite sure how to find everything in? There are many people who have put themselves in this unfortunate predicament before, and the results can be devastating. That is to say that they are not app with the outcome because they end up getting lost in the maze of the app and are unable to truly enjoy its benefits. Creating lists within the app makes it a lot easier for anyone to take a look at what is going on within the app and try to figure out which steps they need to take next to get to the information that they actually desire. As you might imagine, this is a very big deal when working with apps that contain valuable information within them. If you are working with something like that, then you definitely want to get to the root of what you are looking for right away. The ability for users to discover what they are looking for always begins at the development stage. When developers are working to create apps that people will actually use, they need to think carefully about the way that the average user is likely to approach the app. How is that user going to view the material that is accessible in the app, and where are they most likely to click? Those are the type of questions that developers should always ask themselves if they are serious about creating something that is going to stand the test of time. A post with code in it. Because it’s been a long time since the last one. If you work with ListViews in Android, as all Android developers will do at some point, you may notice that if you set your list items to be non-selectable the dividers that are drawn between each cell disappear. In the Holo Light theme you would normally get a thin light gray dividing line between cells. Depending on how you’ve implemented your adapter, you may find that these dividers become white/transparent when the cells are not selectable. According to Android framework engineer Romain Guy, this is the intended behavior. As Haythem Souissi points out in this Stack Overflow answer, you can work around this by ensuring that the areAllItemsEnabled method returns true, even though all items are not enabled (maybe none of them are). The isEnabled method will take care of actually disabling the cells and the dividers will be drawn between each of them. All very straightforward so far but it all goes wrong again when you try to add a non-selectable header view to the list. The way that ListView deals with headers and footers is that it creates its own adapter to wrap/decorate yours and insert the header/footer views in the appropriate places. This is fine but it’s not delegating the areAllItemsEnabled method, so our above fix no longer works. Fortunately, and unusually for Android, everything we need to resolve this issue is part of the public API. The adapter decorator class is android.widget.HeaderViewListAdapter. We just need to create our own instance, wrapping our own adapter, and override areAllItemsEnabled as above. There’s a slight complication in that we have to wrap the header view in an instance of ListView.FixedViewInfo and this is a non-static inner class of ListView, but we can reach into our bag of obscure Java tricks to create an instance from outside the enclosing class. // I assume you know how get a reference to the ListView and create your own adapter. ListView listView = (ListView) view.findViewById(android.R.id.list); CustomAdapter adapter = new CustomAdapter(context, listOfItems); // You can create any view you like for the header. TextView listHeader = (TextView) inflater.inflate(R.layout.list_header, null); listHeader.setText("My Header Text"); // This is how you create an instance of the non-static nested class, providing // it with a reference to an instance of the containing class (ListView). ListView.FixedViewInfo headerInfo = listView.new FixedViewInfo(); headerInfo.view = listHeader; headerInfo.isSelectable = false; // HeaderViewListAdapter insists on concrete ArrayLists. ArrayList headers = new ArrayList(1); headerInfoList.add(headerInfo); ArrayList footers = new ArrayList(0); HeaderViewListAdapter wrapper = new HeaderViewListAdapter(headers, footers, adapter) { @Override public boolean areAllItemsEnabled() { return true; } }; listView.setAdapter(wrapper); Create Something Unique for Android? Here is another thing that people sometimes forget about. They may want to consider creating something unique for the Android system. There are plenty of Android users out there, and it is a great platform on which to launch your application to get it started. If you discover that the ListViewer and every other piece of code you have placed into your app works out well on the Android platform, then there is a good chance that it will do great on other platforms as well. Thus, you may bring it over to those other platforms after you have given it a chance on the Android system. See what Android users love and hate about what you have created, and then fix the problems and move on to the next challenge. You may find that you have created something that users truly love and that you can market to other users on different operating devices (such as Apple iOS). The best thing to do is to figure out the issues that you may need to clean up while putting your material out to a large audience. The Android platform is a large enough audience that you should be in great shape if you begin there. They are also helpful in that they will provide you with the feedback that you may need to make your app just right. Don't Create Too Many Lists Finally, we leave you with the reminder that you shouldn't create too many lists within your app. Yes, you want people to come and check out what you are all about, but you do not want to give them the impression that they have to continue to click through sub-list after sub-list just to get to the materials that they are actually attempting to view. If you put them in a position like that, then they may feel that you are making things too challenging for them, and this is likely to upset some users. Get away from that by only using lists when they are truly necessary within your app. Otherwise, try to cut them out and keep a clean and crisp look to what you have created. At the end of the day, users want two things. The first is that they want an app that can help them solve whatever issue your app seeks to solve. The second is an app that has a user-friendly and clean look to it. You can give them both of those things if you just work with what you have created to make it as smooth and seamless as possible. It is not as challenging as you may at first believe. Give it a try, and discover a whole new world of possibilities.

Netbeans Platform Offshore has received an increased amount of attention given the massive amount of attention placed on the supply chain crisis that has occurred all throughout the world in recent years. Modern ships rely on NetBeans Platform Offshore and similar technologies to help guide them where they need to go. Thus, the world's reliance on Netbeans Platform Offshore could not be more obvious at this time. Better Software Systems Onboard Ships Make Them More Reliable Cargo ships and other naval vessels are very delicate pieces of equipment that can be easily disrupted by a malfunctioning piece of software equipment. If something goes wrong with the Netbeans system onboard, then a ship can be routed in the completely wrong direction from where it was intended to go. Obviously, the world of global commerce simply cannot allow for this to happen, and companies are responding to the need. Software Can Help Maintain Crew Safety Netbeans is being relied upon more than ever for crew safety at this point. After a review of all known marine system models, the Netbeans system was built to incorporate all of the best parts from each system to help promote safe passage and crew safety while on board the ship. At the same time, developers had to ensure that the enhanced security features would not hinder the ship from going where it needed to go. After all, the world of commerce moves faster than ever before these days, and there is no way that slowing the ship too much would be permitted by the companies that own and operate these vessels. They care about their profits and bottom line, and they wouldn't want to give those up too much. Modern ships and rigs have advanced computer systems for dynamic positioning, power generation and distribution, and drilling operations. Software errors in these systems lead to delays and non-productive time, and compromise safety. Marine Cybernetics performs independent testing and verification of computer system software to detect and eliminate such errors and weaknesses using Hardware-In-the-Loop (HIL) testing technology. Centralized Control and Overrides Two important things about the Netbeans system is that it provides both centralized control over the vessel and also allows for human overrides as necessary. If there is ever a situation in which the software program is incorrect in its assumptions or makes an error, humans can jump in and make the necessary corrections to get things right. It is wonderful to see the two things working in tandem, and it provides strong evidence that this is the way forward. Based on our extensive library of marine system models, we build applications and user interfaces for our testers and customers, based on the NetBeans Platform. The modular nature of our simulators and the diversity of test programs and vessel configurations make the NetBeans Platform a natural choice. Coupled with Maven, Hudson and an agile approach to software development, the NetBeans Platform enables us to quickly roll out new applications and adapt to the changing offshore industry. The screenshot above is taken from a Power Plant HIL Simulator, but we also make HIL simulators for Dynamic Positioning, Steering, Propulsion, Thrusters, Drilling Systems, Cranes and other systems. Our database of test programs and procedures is also powered by a NetBeans Platform application. Independently Verified Finally, one more reason to rest easy with the Netbeans system on board is the fact that it has been independently tested and verified. A third-party has been brought in to help ensure that the system is working as designed. That is clearly a very big deal because not every company would be so willing to work with outside auditors to ensure that everything was working as designed, but the makers of Netbeans are perfectly fine with doing exactly that. They want to make sure their systems are the safest and most tested on the planet, and they are not afraid to let another party poke around those systems to discover if this is the case. Continue to check out what Netbeans comes up with next as they are sure to provide the world with very interesting and useful equipment. Could More Useful Onboard Technology Help Supply Chain Issues? Unless you have had your head under a rock for the last several years, you are well aware of the fact that there have been some major supply chain issues that have caused trouble for seaports all throughout the world. Instead of getting things to customers right when they require them, many shipping companies have been woefully behind on getting their shipments to customers as designed. Thus, people are starting to ask if it might be possible to use onboard technology to help get the cargo from ships to where it needs to go much more quickly. Indeed, it does feel like there is some hope that some of the technologies that Netbeans has produced could help prevent some of the hang-ups at ports. This is not to suggest that Netbeans can do it all by itself, but there are plenty of people working on the problem, and it feels like a little extra guidance technology may be exactly what is called for to get the job done. Yes, there are going to need to be even more people hired to keep freight moving where it needs to go, but we cannot forget the fact that there are a lot of people counting on crews to bring their supplies to them in a timely fashion. The best way to reach that goal is to use the most up-to-date technologies in the world to make it happen. Navigation is a must for all shipping concerns, and having the best technologies on board means that one can finally get ships where they need to go. Estimates suggest that literally billions of dollars have been wiped off of the economies of the world because of supply chain issues. The fact that some of this can be remedied by just getting ships where they need to go is a wonderful piece of news for all involved. Tracking Shipping Containers and More Expectations are such that Netbeans may have the ability to track shipping containers and provide other valuable insights into what is going on in the world of shipping. If so, the value that they provide will surely skyrocket. The entire world relies on shipments that are brought to them via the ocean, and any system that can help make that process a bit smoother is going to be lauded as the next great thing when it comes to economic growth and stability. Netbeans is here to help bring that next chapter forward, and we all owe them a debt of gratitude for the work that they are actively doing to help all mankind.

Use this guide to grab eclipse console output effortlessly. After reading it, you'll be able to grab eclipse console output successfully. But before we dive into it, let's start by answering this crucial question: What is the Console in Eclipse? The Console in Eclipse is what will enable you to view the output of the utilities invoked when building a project or the program's output when you run or debug running the application. Typically, you will follow these easy steps to view the output: Click Window > Preferences. Expand C/C++ and Build, then click Console. If you want to display information on the latest project only, use the "Always clear console before building check box" option. Optimize Each Line Of the Eclipse Output In your plugin, if you want to do something with each line of your eclipse output console, for example, write that line to a file or parse it before sending it to your custom eclipse view, you should create a class that implements IConsoleLineTracker, and you should add this extension point to your plugin.xml. [img_assist|nid=1032|title=|desc=The steps are explained well here...|link=none|align=none|width=256|height=192] Now, suppose your class implementing IConsoleLineTracker is this: public class LogTracker implements IConsoleLineTracker { private IConsole m_console; public void dispose() { } public void init(IConsole console) { m_console = console; } public void lineAppended(IRegion region) { try { String line = m_console.getDocument().get(region.getOffset(), region.getLength()); // DO SOMETHING WITH THAT LINE } catch (BadLocationException e) { WrCheck.logError(e); } } } Copy the console output in Eclipse The best method you can use to copy a console is to tell Eclipse to save console output to a file. To do this, you need to go to Run → Debug Configurations on the Eclipse menu. Once you Debug Configurations successfully, then navigate under the Standard Input and Output section, click on the checkbox next to File: and choose the name of the output file to use. Get the full Console in Eclipse Are you trying to get full console in Eclipse? The good news is it's possible to get it. All you need to do is go to Windows --> Preferences --> Run/Debug --> Console and then unchecking "Limit Console Output" which is ON by default. This works on STS any version too. This would help print complete console output. For a Mac, it is Eclipse > Preferences > Run/Debug > Console. View the console log in Eclipse If you want to view the console login to Eclipse: You need to go to Run -> Debug Configurations on the Eclipse menu. Then, under the "Standard Input and Output" section, Click on the checkbox next to "File:", and choose the name of the output file to use. If you check "Append" underneath, console output will be appended to the output file. How do I save data on the console? There will be times when you'll need to save data on the console. To do this, all you need to do is right-click > go to Save button, which is in the Console panel. It will allow you to save the logged messages to a file. In a situation where you have an object logged, then you can use the following steps: Right-click on the object on the console and click Store as a global variable. The output will be visible as "temp1.type in console". Copy (temp1), And paste it to your favorite text editor Install a detached console in Eclipse Want to attach the console to the main eclipse window? Follow these easy steps: Click Window->Perspective-> then go to Reset Perspective to detach it. EFCARDZ TREND REPORTS WEBINARS ZONES DZone > Performance Zone > Remotely Debugging an Eclipse Plugin Upgrade Eclipse Follow the instructions below to upgrade Eclipse: On the toolbar, navigate to Window > Install New Software. Click on Add and add the following URL for the latest build of Eclipse: https://download.eclipse.org/releases/latest. Alternatively, you could add the specific build of Eclipse you want from https://download.eclipse.org/releases/ such as: https://download.eclipse.org/releases/photon/ or go to https://download.eclipse.org/releases/2019-09/. Once the site is added to Eclipse, you can now proceed with the upgrade by navigating to Window > Help > Check for Updates. This basically goes through all the sites under Window > Preferences > Install/Update > Available Software Sites and gathers updated details from the ones that are selected. You should be able to see a pop-up listing the various plugins/tools that require an update. You have the option to select the ones that you need, or you can leave them as is. Then, click Next. Click Next after reviewing the details. You should now see the review license page. Click on the radio button "I accept ...." and click Finish. Remotely Debugging an Eclipse Plugin The Eclipse plugin can be debugged from inside the IDE while in the development phase, but once the plugin is installed in the IDE, we need to debug it remotely for bug resolution. In this quick tutorial, I'm going to explain how to debug an Eclipse plugin remotely. Plugin Project Let's suppose we have developed our simple Hello World plugin and installed it in our IDE. Now, to debug the plugin remotely, please follow the steps below. Step 1 Open the first instance of Eclipse IDE pointing to the workspace where your Hello World plugin project is located. Step 2 Navigate to the eclipse.ini file of your IDE. Here is a screenshot of the location of the file in macOS. Now add the following JVM arguments to the file: 1 -vmargs 2 -Xdebug 3 -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=1044 Step 3 Now, open another instance of the Eclipse IDE (on macOS, use the command open -a -n Eclipse in the terminal). This instance will point to a workspace different from the one which contains the Hello World plugin project. Step 4 Now, in the workspace containing the Hello World plugin project, make the following remote debug configurations/; Navigate Run -> Debug Configurations -> Remote Java Application. Then hit the debug button. Also, do not forget to put break-points in the code of the Hello World plugin to be debugged. Step 5 In the other workspace (which does not contain the Hello World plugin), try to use the Hello World plugin and it will be remotely debugged in the other instance of Eclipse. Conclusion There are Eclipse-based IDEs that have a powerful feature to make ‘variants’ of the same projects. Use the to Build Configurations, which are a powerful feature in Eclipse. They will allow you to make ‘variants’ of a project. The project will share the common things, and you can simply tweak things one way or the other for example to produce a ‘release’ or a ‘debug’ binary of my application without duplicating the project.

If you wonder what a JMF player is, you are in the right spot. We've noticed that many aspiring developers want to try it out but are unsure how it works. Hence, we decided to put together this guide to make things a tad easier for you. package org.jmf.example; import javax.swing.JDialog; import javax.swing.JFrame; import javax.swing.UIManager; import javax.swing.UnsupportedLookAndFeelException; import javax.swing.plaf.metal.MetalLookAndFeel; public class ExampleJMF { public static void main(String[] args) { JFrame.setDefaultLookAndFeelDecorated(true); JDialog.setDefaultLookAndFeelDecorated(true); try { UIManager.setLookAndFeel(new MetalLookAndFeel()); } catch(UnsupportedLookAndFeelException e) { e.printStackTrace(); } new exampleFrame(); } } But before we dive into it, let's answer this crucial question: What is Java? Java is a high-level language that programmers use to develop projects with few implementation dependencies. Java has transformed the web in many ways. A vast majority of online tools that we use today were built on Java. That includes websites mobile apps and multimedia playback platforms. This programming language has come a long way. This year it will be 27 years since James Gosling developed it. What is a Java Media Framework JMF is an API that enables you to play, process, and capture media audio and video. Whether you want to transmit or receive live media broadcasts and conduct videoconferences, you can easily do it thanks to this API. All thanks to RTP ”Real-time Transport Protocol of the JMF. A JMF is a straightforward player that encapsulates your multimedia component and allows you to control your player. It also offers methods that enable you to acquire necessary resources and query the current state. These are tools you will use to build page objects. For instance, if you want to scan the page and create a class. Here is what Java Media Framework can do: A multifunctional tool A JMF comes in handy, especially if you're looking for a tool that can scan a page and build a class. You can also use it to create prototype code and later build a robust application. Instrumentalization A lot of what you read about the topic of Observability mentions the benefits and potential of analyzing data, but little about how you collect it. This process is called “instrumentation” and broadly involves collecting events in infrastructure and code that include metrics, logs, and traces. There are of course dozens of methods, frameworks, and tools to help you collect the events that are important to you, and this post begins a series looking at some of those. This post focuses on introductory concepts, setting up the dependencies needed, and generating some basic metrics. Later posts will take these concepts further. An Introduction to Metrics Data Different vendors and open source projects created their own ways to represent the event data they collect. While this remains true, there are increased efforts to create portable standards that everyone can use and add their features on top of but retain interoperability. The key project is OpenTelemetry from the Cloud Native Computing Foundation (CNCF). This blog series will use the OpenTelemetry specification and SDKs, but collect and export a variety of the formats it handles. The Application Example The example for this post is an ExpressJS application that serves API endpoints and exports Prometheus-compatible metrics. The tutorial starts by adding basic instrumentation and sending metrics to a Prometheus backend, then adds more, and adds the Chronosphere collector. You can find the full and final code on GitHub. Install and Setup ExpressJS ExpressJS provides a lot of boilerplate for creating a JavaScript application that serves HTTP endpoints, so it is a great starting point. Add it to a new project by following the install steps. Capture media streams Not only does the JMF allows you to play music, but you can use it to capture media content as well. And all this will happen while you process and capture it from a source to a destination. You'll then identify each media stream by its content format. From there, the JMF will present the content of that specific video stream. Each media stream will have at least one or more tracks that you can play. Identify each media stream by location You can either identify your media stream by using uniform resource locators (URLs) or media locators. It doesn't matter how you locate them. What matters most is that you wouldn't struggle to identify each media stream. Process Time Bases and Clocks You can also play time-based media, or capture them at an accurate time. To achieve this, JMF requires time-bases and clocks. So, without a thorough understanding of time bases and clocks, you won't be able to work with JMF. While at it, use the below 1. Eliminate Unused Tables Usually, when you remove or deactivate a plugin, all the database tables remain. This can be a good thing, as you retain all the user information, preferences, and other data. However, in most cases, you’re left with a cumbersome dataset that may bring your server’s performance down. If you’re using WordPress, you can get rid of leftover tables by installing a plugin called Plugins Garbage Collector. It scans your database for any unused tables, and you can delete the ones that you know aren’t needed. A more hands-on approach is finding inactive tables using the UPDATE_TIME string. 2. Create an Execution Plan The execution plan’s main goal is to display the various methods of retrieving data by containing the operation's type and order when creating a query. If you’re not familiar with execution plans, here’s a video going through the basics. The typical execution plan includes the following: Types of operations Order of operations Indexes to use Row count estimates from stats Row count actual from results 3. Use Proper Indexing Indexing allows for faster access to the database and speeds up the queries. If you don’t use indexes at all, then processing the queries becomes painfully slow. Yet, over-indexing your database is also ineffective. Unfortunately, there isn’t a golden rule for optimizing your database the right way. However, with some trial and error, your database benefits from an index system. 4. Avoid Coding Loops A SQL query that runs more than once is inefficient and can cause unnecessary performance issues, which pile up quickly, especially with large datasets. In essence, moving a query outside a loop with the goal of it executing only once is the way to go. There are a couple of nifty solutions to achieve this. Use JOIN and GROUP BY to select data from multiple tables and have the database perform the counting with a single query. This is especially effective for multiple queries, including COUNT and MAX clauses. 5. Get Rid of Correlated Subqueries Correlated subqueries are essentially coding loops. The subquery runs row-by-row until it satisfies the parent statement. This method of processing is useful when the outcome relies on multi-part answer validation. You can avoid the correlated subqueries by using JOIN clauses, which makes the query run more efficiently. Essentially, this method replaces WHERE and removes the necessity to execute the subquery for each row separa 6. Avoid * Queries The ultimate goal of every query is to retrieve relevant data for maximum efficiency. However, it’s relatively common to use SELECT * clauses when creating a query resulting in unnecessary data. While it doesn’t play a massive role in the performance of small datasets, it can leave a significant dent in larger ones. Selecting the data sparingly helps with optimizing the query speed and reduces resource usage. A quick way to turn this issue around is using the LIMIT clause instead of SELECT *. This way, you limit the output of the query results unless you do need the entire dataset retrieved by the query.

Realm Academy has free mobile development tools to help you change the world.

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