It seems like anyone who knows how to copy code from an Internet search or put a semicolon at the end of a line calls themselves a developer. However, how do you sort those who understand development from those who just want to? The answer may be in these ten interview questions that every developer should know. Developer is the workhorse role in the software development process, as the ” Anatomy of a Software Development Role: Developer ” article points out.
Image source: https://s3.amazonaws.com/StartupStockPhotos/uploads/19.jpg
No author listed, from startupstockphotos.com
A: A candidate’s answer should include that validating user input should happen client-side to provide instant feedback, and server-side to ensure that malicious data isn’t injected. For methods to be safe, they need to validate any input parameters they get, particularly if they can be coming from a user.
Image source: https://pixabay.com/en/checklist-test-check-cross-correct-1402461/
Author: ellisedelacruz
A: The answer here focuses on the need for some caching to improve scalability and performance, as well as the problems with cache coherency and staleness. Candidates should be aware of these problems and understand that they require special architectural considerations. Developers aren’t asked to address major architectural issues, but need to know when they might occur.
Image source: https://www.flickr.com/photos/redjar/113152393/
Author: redjar
A: Every candidate should be aware of basic error handling, including the idea of wrapping errors in more context and throwing them up the stack until they can be logged. Developers understand that exceptions should not be allowed to bubble back up to the user.
Image source: https://pixabay.com/en/smilies-emoticons-especially-1607164/
Author: geralt
A: The answer may vary, but should include online forums or local community groups, as well as reading books, articles, Web sites, or other materials and online videos. The intent of the question is to ensure that the candidate will continue to improve over time through continuous learning.
Image source: https://pixabay.com/en/download-boy-man-learn-cloud-1666700/
Author: geralt
A: Some developers prefer working on slick user interfaces. Others are at home writing data processing logic. Still others love complicated logic puzzles. This question seeks to get a sense for what excites a candidate.
Image source: https://skh-careers-in-technology.wikispaces.com/file/view/video-game-designer.jpg/338253666/520×379/video-game-designer.jpg
No author listed, from skh-careers-in-technology.wikispaces.com
A: One way to know how excited a developer is about their craft is to ask them what they do for fun. Good developers connect the proverbial toaster to the Internet. Employers want employees who enjoy what they do—because they’ll be better at it.
Image source: https://s3.amazonaws.com/StartupStockPhotos/20140808_StartupStockPhotos/24.jpg
No author listed, from startupstockphotos.com
A: The best reusable objects have a single focus and do it—whatever that is—very well. The candidate’s answer should talk about the objects that have been built and why they were so valuable. The thinking behind building reusable objects helps developers be better at all kinds of development.
Image source: http://www.themindfulword.org/2014/new-year-new-complexities-resolutions-goals/
Author: David Niblack
A: The goal of the question is to discover some of the hidden tools that developers use to debug. Answers can be “old school,” such as outputting information or logging. They might be tools integrated into the development environment, or third-party tools. Debugging is a substantial amount of the time spent developing code—so knowing how to debug is essential.
Image source: https://www.flickr.com/photos/brungrrl/10987315355/
Author: Stacy Brunner
A: Developers are often called upon to make decisions as to which settings should be configurable—and which shouldn’t—as well as how default values should be handled. A candidate should be prepared to talk about how they make values configurable, default reasonable values, and how they document those that are changeable.
Image source: https://www.flickr.com/photos/longzheng/3492524719/
Author: Long Zheng
A: Development isn’t just about where the semicolons go. Candidates have to have basic skills and language/platform knowledge. However, it’s just as important to understand the industry they’re in or the departmental/functional needs.
Image source: http://stackoverflow.com/jobs/124180/lead-software-developer-windows-clients-lundalogik-ab
No author listed, from stackoverflow.com
It seems like anyone who knows how to copy code from an Internet search or put a semicolon at the end of a line calls themselves a developer. However, how do you sort those who understand development from those who just want to? The answer may be in these ten interview questions that every developer should know.
Your name/nickname
Your email
Subject
(Maximum characters: 1200). You have characters left.

© Source: http://www.developer.com/mgmt/slideshows/ten-developer-interview-questions-you-should-know.html
All rights are reserved and belongs to a source media.

Java provides extensive support in its core API for working with images. Image processing is a vast area in its own right. Serious programmers in this domain use more than one tool/library, such as OpenCV , to work with images. Java, being a general purpose language, supports the essential features for common programming needs. However, the OpenCV library has its Java counterpart that can be effectively used for implementing more crude operations with the images. This article explores the key aspects of working with images using the core API library with a brief introduction on some background information.
As we talk of images in computing, they are of different types; the term colloquially mean graphics, pictures, images, logos, and so forth. This article makes no distinction and designates one and all of them as images; in fact, they are same from the programming point of view. The basic property of an image is defined by its dimension, resolution measured in pixels, and the coordinate system independent of the drawing surface. An image in Java is primarily an object of the Image class. It is a part of the java.awt package, along with many other auxiliary imaging classes and interfaces. These core APIs are used mainly for;
But, before delving into these processes, let’s get an idea of image file formats.
The information about the combination of color, pixels, and dimensions make an image file. They need to be stored in memory. As a result, the information has to be represented in an array of bits. An image file becomes quite large when represented in an simple array of bits. So, a mechanism is devised to compress them so that it not only reduces the file size but also retains visual quality. This is exactly what the encoding technique does. It arranges the bits in a manner that can be stored in a digital medium or transmitted easily in a network. Each encoding technique defines an image file format.
File formats are the data structure on how image information is encoded and stored in a repository. Understandably, these encoding techniques are quite complex and heavily depend upon complex mathematical formulation. Many of them are standardized and commonly used on the Web. The three most common file formats that we always encounter are JPEG (Joint Photographer Experts Group), GIF (Graphics Interchange Format), and PNG (Portable Network Graphics). There are many others, such as TIFF, Exif, BMP, and so on. Let’s stick to only three of them for now:
The most common class in the Java API that deals with images is java.awt. Image. Image is an abstract class, sub classed by BufferedImage and VolatileImage. Among these two, BufferedImage is most frequently used.
Figure 1 : Classes of images
Images are displayed using drawImage methods of the Graphics class.
** Extracted from Java API documentation
This method displays the images passed as a reference. Apart from the coordinates passed as a parameters, the method drawing an image is associated with the ImageObserver interface and Color class. The Color class encapsulates the colors in the RGB color space and an implicit alpha value that specifies the transparency. The ImageObserver interface receives notification as the image is being updated. This is particularly useful to show the progress of image update of a large image or while downloading image from a slow network connection.
As per the Java API documentation and Chet’s VolatileImage Q&A , the concrete subclass BufferedImage uses an accessible data buffer and relies on the image manipulation techniques defined by the methods of java.awt.image. Raster and the color characterization methods of java.awt.image. ColorModel. BufferedImage objects are allocated in an area that is in full control of the application. VolatileImage objects, on the other hand, are created in the limited system resource area, such as VRAM. Such limited resource areas are not in control of the application. As a result, the objects may be garbage collected as a result of optimizing limited resources or due to a proactive call of the flush method. So, the use of the VolatileImages object is unreliable or should be used cautiously. However, when the question of rendering performance arises, VolatileImage has the leverage of hardware rendering, whereas BufferedImage has to remain satisfied with the software rendering performance.
Images that we’ll be using in the code below are as follows.
Name: starburst.jpg
Size: 350×200
Figure 2 : Starburst image
Name: blob.jpg
Size: 50×50
Figure 3 : A blob
As with working with any basic file, images are loaded from an external file stored in a digital medium or an URL from the network; then, an image is created and finally saved. The following code will show how to do it in a simple manner.
Images need to loaded or created in a GUI component. We’ll be using java.swing. JPanel as a container for our images. The paint method of this component can be overloaded to create the image. The paint method is automatically invoked to render the component on-screen. It takes a Graphics object as a parameter. This object reference is used to create the image.
Here, we’ll be loading two images superimposing one on other, write some text, and finally save the image as a jpg file onto the disk.
Figure 4 : Starburst image with control buttons and the blob
The imaging classes provided in this are article are just tip of the iceberg. The core API library has several other classes that can be used to have a better control over imaging process and support advanced imaging techniques. Some of the classes are described in package javax.imageio. Other classes such as MediaTracker which enables checking the status of arbitrary number of images in parallel, interfaces such as ImageProducer , ImageConsumer to work with image data, ImageFilter objects can be used to manipulate pixels in the images. In a nutshell, the core API library along with a third party library such as OpenCV can provide almost every need of an image processing programmer.

© Source: http://www.developer.com/java/data/working-with-images-in-java.html
All rights are reserved and belongs to a source media.

Airbus is not kidding around about flying cars – the maker of airborne transportation vehicles plans to test out a prototype self-flying small urban transport made for single-passenger travel by the end of this year, according to Airbus CEO Tom Enders (via Reuters ). Airbus has been developing its autonomous vertical take-off and landing (VTOL) concept through Project Vahana , an internal project designed to test viability and refine a prototype for urban air transport.
The project is something that Airbus takes “very seriously,” Enders told the DLD tech conference in Munich on Monday, noting that airborne transit for goods and individual passengers would actually be tremendously beneficial in terms of alleviating urban congestion, and reconfiguring how urban planners think about designing cities.
Vahana aims to have a viable production urban aircraft for short-haul trips available by 2021, and so actual prototype tests by the end of this year make sense given those timelines. In fact, the company previously said it was hoping to field a full-scale prototype sometime in 2017, so it looks like Enders is still committed to keeping his company to that timeline, including active flight testing.
The vehicle will likely use a four-rotor design with variable positioning possible to help with vertical take off, and then shift for propelling the craft through the air. The design process is taking into account what’s feasible and most efficient, given requirements like an electric motor, which Airbus is focusing on so that a fleet of the vehicles, once deployed, will not actually have a worse ecological impact than ground-based transportation in terms of contributing to air pollution.
Flying cars may still seem outlandish and primarily the province of science fiction, but helicopter-maker Airbus actually believes that they’d be ignoring the category at their peril, given the pace and progress of technology that can help make it possible, including autonomous driving systems and electric battery tech.
The proof will still be in the flying pudding, but at least now we could get a glimpse of that later this year. If Airbus can pull off the prototype, the biggest hurdle might be regulation – transporting humans by drone is still a big legal no-no in dense metropolitan areas, and it’ll be a challenge to prove its safety both to end users and municipal regulators.

© Source: http://feedproxy.google.com/~r/Techcrunch/~3/pnEO1uzm0EE/
All rights are reserved and belongs to a source media.