Do you want more leads from LinkedIn? Wondering how others turn connections into leads? With the right approach, you can be the first person your connections think of when they need someone in your industry. In this article, you’ll discover how to turn LinkedIn connections into qualified leads. #1: Build Your Network Strategically When people first [...]
This post 5 Steps to Generate More LinkedIn Sales Leads first appeared on .
- Your Guide to the Social Media Jungle
One of nicest features of Java is its rich, multifaceted nature. Sure, building traditional desktop and even mobile applications is all well and fine. But what if you want to leave your current background behind and start stepping on the web terrain? The good news is that the language ships with the fully-fledged Servlet API, which lets you build robust web applications without much hassle.
The question that must be spinning in your mind now is “How?”, am I right?
Enter servlets, a specific type of Java program executed within the scope of a web container (also called servlet containers, Tomcat and Jetty are prime examples), which allows to handle client requests and server responses in a straightforward and performant fashion. This isn’t the place and time for boring you to tears with academic definitions on what a servlet is. Suffice it to say that servlets are instantiated and destroyed by their containers instead of the developer and act as a middle layer between clients (usually web browsers) and other applications running on the server (databases, for example).
Servlets are powerful creatures, which, among other nifty things, can grab data from the client, typically through GET and POST requests, handle cookies and session parameters, process the data via additional application layers, and send the output back to the client in both text and binary formats (HTML, XML, PDF, JPG, GIF, and so on), in many cases by using a Java Server Pages (JSP) file.
The best way to get started using servlets is with a concrete example. Thus, in the next few lines I’m going to build up a simple web application that will let customers sign up using a plain HTML form. Data submitted by customers will be collected by a servlet and validated at a very basic level through some static helpers.
To have a clear idea on how the customer application will be structured, here’s how it will be laid out:
Nothing unexpected, right? But first things first.
The first step we need to take to build the application is to define the so-called deployment descriptor (DD). As the name suggests, it specifies how an application should be deployed in a specific environment. Not surprisingly when it comes to web applications, the deployment descriptor is a plain XML file called web.xml and is part of the standard Java EE specification. In this particular case, it’ll look like this:
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.1"
xmlns="http://ift.tt/19L2NlC"
xmlns:xsi="http://ift.tt/ra1lAU"
xsi:schemaLocation="http://ift.tt/19L2NlC http://ift.tt/1drxgYl"
metadata-complete="false">
</web-app>
As shown above, the web.xml file contains no directives at all and only defines the version of the Java Servlet Specification (3.1) that we’ll be using across the application. It can of course hold a lot more content, including servlet mapping directives, intialization parameters, a list of welcome files and a few additional settings. But to keep the whole development process easy to follow, I’ll keep the file that simple.
Since the sample application will consume the Servlet API and also use Java Server Pages for displaying customer data, we need to grab all the required JARs. Maven will do the tough work for us, so here’s how the POM file will be defined:
<project xmlns="http://ift.tt/IH78KX" xmlns:xsi="http://ift.tt/ra1lAU"
xsi:schemaLocation="http://ift.tt/IH78KX http://ift.tt/HBk9RF">
<modelVersion>4.0.0</modelVersion>
<groupId>com.electricalweb.customerapplication</groupId>
<artifactId>customerapplication</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>Customer Application</name>
<url>http://ift.tt/1xLIsqm;
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>javax.el</groupId>
<artifactId>el-api</artifactId>
<version>2.2</version>
</dependency>
</dependencies>
<build>
<finalName>Customer Application</finalName>
</build>
</project>
In a nutshell, the pom.xml file defines all the dependencies required for working with servlets: JSP, the Java Standard Tag Library (JSTL), and the Java Expression Language (JEL).
At this point, we've managed to create the customer app configuration files. However, in its current state the application literally does nothing. Yikes! Since the primary goal here is to let customers sign up using an HTML form, the next thing we need to do is to define the JSP files tasked with rendering the aforementioned form and with displaying customer data once the signup process has been successfully completed. That’s exactly the topic covered in the next section.
The presentation layer will be made up of two JSP files - in an MVC context, these are called views. The first one will be responsible for rendering the signup form and for displaying eventual errors triggered after validating the inputted data. The second one will be a typical welcome page, which will show the data submitted by the customer after successfully completing the signup process.
Continue reading %Building a Web App with Java Servlets%
We’re excited to announce the lucky winner of our Leading The Product competition! The winner gets a free ticket to this inspirational event for product people in the Southern Hemisphere, which includes great talks and presentations, plus networking events, Q&A sessions, lunch and snacks and the after party—woohoo! (total value $500+)
We asked: “What’s one thing you wish you could get Product Managers to understand?” and got some fantastic responses, but we could pick only one.
Drumroll please—the winner is…
Christina Porter – congratulations!
In her winning entry, Christina explained why it’s important to always keep improving, and not just react to customer complaints. We couldn’t agree more – it’s this attitude that leads to truly exceptional products.
Christina’s entry:
“Just because users are not complaining, does not mean we cannot make things better for them! And it most certainly does not mean that the product cannot be improved.
By taking that extra step and making the experience enjoyable, users are much more likely to return to the product, to recommend the product, and in the long term, your company will be more likely to succeed in selling the product. But if you work on the theory that, “if it’s not good enough then people will complain”, then you are likely setting yourself up for failure (unless by pure luck, you somehow manage to design an absolutely perfect product on your first attempt – but I would be surprised about that!).”
Enjoy the conference, Christina!
Honourable mentions go to Kate Needham, Sunil Dogra and Ashleigh – we’ve included their entries below. We love your work, too!
Kate Needham: “UX is everyone’s responsibility. When everyone keeps the user at the centre of everything they do, everyone wins. A Product Manager’s vision + a UX Designer’s insights = magic.”
Sunil Dogra: “That they are not the ‘customer’ and tailoring the product according to their own perceptions, experiences and biases without taking customer feedback or getting customer insights leads to a product that doesn’t connect with the real customer.”
Ashleigh: “The importance of defining the actual problem before deciding what the solution is.”
Thanks to everyone who entered!
It’s not too late to book your spot at Leading the Product 2016, in Melbourne on 20 October and Sydney on 25 October. For all the details and the full speaker lineup, visit http://ift.tt/29kU4yg and follow @ltp_aus for updates.
The post Winners of our Product Management competition appeared first on UX Mastery.
A thought provoking post by Tim Kadlec that highlights some interesting points about tools and why and when we should move to another or just stick it out and learn the inner workings of them. This post is a great segway into the post below. (timkadlec.com)
Well as JavaScript continues to dominate our industry it’s probably a good time to sit back and have a bit of a chuckle at what we have got ourselves into. (hackernoon.com)
If you have worked on a JavaScript app I’m sure this post will be of interest. Managing state is hard. Tal Kol lists some practical tips of how to model app state to keep yourself sane. (hackernoon.com)
Jamie Knight reveals the techniques the BBC uses to speed up its site and help users flow from one page to the next. (medium.com)
If you are keen to get into the nitty gritty of web front optimization this post by Ilya Grigorik is just for you. It’s pretty epic and offers loads of good tips. (developers.google.com)
Joren Van Hee explains how to make a flex item behave like it has two flex grow values without the use of media queries. (joren.co)
The smart team at Walmart Labs has open sourced the React + Node-based platform that powers the main Walmart site. It focuses on performance, component reusability and simple deployment. Looks pretty good. (electrode.io)
Can’t really say I have paid close attention to the mobile frameworks landscape but this post is a good overview of what is currently trending. (agingcoder.com)
7 videos put together by Rachel Andrew that look into how Grid Layout works and some of its features. (gridbyexample.com)
David Den Toom explains in a clear and concise manner how to setup lazy loading in Angular 2 using Webpack. (medium.com)
A small project that mimics command line spinners and brings them to the web. (tawian.io)
If you are interested in solving complex problems in an antiquated industry with cutting-edge design solutions, work with designers, product managers and engineers to build the future of global trade, we want to hear from you today. (flexport.com)
Are you passionate about design and web technologies? Are you constantly striving to stay current with the latest industry best practices? Are you able to switch easily between visual design and front-end development? Do you think deeply about your CSS class names? If so, please reach out. (wildbit.com)
A mind boggling site that is executed extremely well. It also uses some pretty hot tech like Service Workers, Web Push and can work offline. (paperplanes.world)
The post Web Design Weekly #255 appeared first on Web Design Weekly.
This article is by guest author Dudley Storey. SitePoint guest posts aim to bring you engaging content from prominent writers and speakers of the JavaScript community.
Animation on the web has long been divided into four disparate camps:
The Web Animations API seeks to integrate the best features of all of these into a single, unified specification, while eliminating the drawbacks, creating a native understanding of keyframes, easing, and element control in JavaScript, with the same on-screen performance as CSS. With core components of the specification now supported in Chrome and Firefox, and development either announced or underway in other browsers, including Safari and Edge, together with the availability of a robust polyfill, it's time to give the Web Animations API serious consideration for bringing web pages to life.
The Web Animations API helps make animation a staple of web design, opening the gates to vendor-optimized performance and 3rd party tooling. — Rachel Nabors (@rachelnabors) September 29, 2016
Let's take one of the simplest possible examples of a keyframe animation: moving a red ball element from one side of the page to the other. Regardless of which technique we use, the element will be the same:
<div id="redball"></div>
As will the initial CSS:
body {
margin: 0;
background: #000;
overflow: hidden;
min-height: 100vh;
}
#redball {
background: red;
width: 30vmin;
height: 30vmin;
border-radius: 50%;
}
I've used vmin units so that the element always remains symmetrical while responding to the size of the viewport.
In CSS, moving the ball from one side of the page to the other would require something like the following:
@keyframes moveBall {
from {
transform: translateX(-20vw);
}
to {
transform: translateX(100vw);
}
}
This animation would be called from the declaration for the red ball element:
#redball {
animation: moveBall 3s infinite;
}
The result, shown in Codepen:
See the Pen Basic CSS Red Ball Animation by SitePoint (@SitePoint) on CodePen.
There are a few things to note about the animation at this point, including the fact that easing (speeding up at the beginning and slowing down at the end) is automatically built in.
Continue reading %Bringing Pages to Life with the Web Animations API%