Wednesday, March 23, 2016

Object Oriented PHP for Beginners

Object Oriented PHP for Beginners
The hardest thing to learn (and teach btw,) in object oriented PHP is the basics. But once you understand them, the
rest will come much, much easier.
But don’t be discouraged! You just found the easiest to understand tutorial out there on OOP and PHP. It may sound
like a boastful claim, I know, but that’s what the nerd zeitgeist is saying.
… Or so I’ve been told.

About This Tutorial

This tutorial is designed to teach total beginners object oriented PHP.
This is not a long-winded theoretical blathering that you see all too often; instead, we actually start
writing OO code very quickly. I believe that this ‘hands-on’ style of learning, makes understanding OO (object oriented)
PHP much easier… and less boring too!
So before you begin, get out your favorite PHP code editor and be ready to write and run some object oriented PHP code.
PS: scroll to the bottom of the page for the supporting videos.
Thanks for reading,
Stefan Mischook

Introduction

With the release of php5 in 2004, php programmers finally had the power to code with the ‘big boys’. Like Java and C#,
php finally had a complete OOP infrastructure.
In this tutorial, you will be guided (step-by-step) through the process of building and working with objects using
php’s built-in OOP capabilities. At the same time you will learn:
  • The difference between building a php application the old fashioned (procedural) way, versus the OOP way.
  • What the basic OOP principles are, and how to use them in PHP.
  • When you would want to use OOP in your PHP scripts.
People run into confusion when programming because of some lack of understanding of the basics. The basics are really important!
With this in mind, we are going to slowly go over key OOP principles while creating our own PHP objects.  With this
knowledge, you will be able to explore OOP further.

Object Oriented PHP for Beginners: Steps 1 – 5

For this tutorial, you should understand a few PHP basics: functions, variables, conditionals and loops.
To make things easy, the tutorial is divided into 22 steps.

Step 1:

First thing we need to do is create two PHP pages:
  • index.php
  • class_lib.php
OOP is all about creating modular code, so our object oriented PHP code will be contained in dedicated files that we will then insert into our normal PHP page using php ‘includes’.
In this case, all our OO PHP code will be in the PHP file:
  • class_lib.php
OOP revolves around a construct called a ‘class’. Classes are the cookie-cutters / templates that are used to define objects.

Step 2:

Create a simple PHP class (in class_lib.php)
Instead of having a bunch of functions, variables and code floating around willy-nilly, to design your php scripts or code libraries the OOP way, you’ll need to define/create your own classes.
You define your own class by starting with the keyword ‘class’ followed by the name you want to give your new class.
<?php 
 class person {

 }
?>

 
Note: You enclose a class using curly braces ( { } ) … just like you do with functions.

Step 3:

Add data to your class
Classes are the blueprints for php objects – more on that later. One of the big differences between functions and classes is that a class contains both data (variables) and functions that form a package called an: ‘object’.
When you create a variable inside a class, it is called a ‘property’.
<?php 
 class person {
  var $name;
 }
?>
Note: The data/variables inside a class (ex: var $name;) are called ‘properties’.

Step 4:

Add functions/methods to your class
In the same way that variables get a different name when created inside a class (they are called: properties,) functions also referred to (by nerds) by a different name when created inside a class – they are called ‘methods’.
A class’s methods are used to manipulate its own data / properties.
<?php 
 class person {
  var $name;
  function set_name($new_name) {
   $this->name = $new_name;
  }
  function get_name() {
   return $this->name;
  }
 }
?>
Note: Don’t forget that in a class, variables are called ‘properties’ and functions are called ‘methods’.

Step 5:

Getter and setter functions
We’ve created two interesting functions/methods: get_name() and set_name().
These methods follow a common OOP convention that you see in many languages (including Java and Ruby) – where you create methods to ‘set’ and ‘get’ properties in a class.
Another convention is that getter and setter names should match the property names.
<?php 
 class person {
  var $name; 
  function set_name($new_name) { 
   $this->name = $new_name;  
   }
 
     function get_name() {
   return $this->name;
  }
 } 
?>
Note: Notice that the getter and setter names, match the associated property name.
This way, when other PHP programmers want to use your objects, they will know that if you have a method/function called ‘set_name()’, there will be a property/variable called ‘name’.

Step 6:

The ‘$this’ variable
You probably noticed this line of code:
$this->name = $new_name;
The $this is a built-in variable (built into all objects) which points to the current object. Or in other words, $this is a special self-referencing variable. You use $this to access properties and to call other methods of the current class.
function get_name() {
 return $this->name;
}
Note: This may be a bit confusing for some of you … that’s because you are seeing for the first time, one of those built in OO capabilities (built into PHP5 itself) that automatically does stuff for us.
For now, just think of $this as a special OO PHP keyword. When PHP comes across $this, the PHP engine knows what to do.
… Hopefully soon, you will too!

Step 7:

Use your class in your main PHP page. (index.php)
You would never create your PHP classes directly inside your main php pages – that would help defeat the purposes of object oriented PHP in the first place!
Instead, it is always best practice to create separate php pages that only contain your classes. Then you would access your php objects/classes by including them in your main php pages with either a php ‘include’ or ‘require’.
<?php include("class_lib.php"); ?>
Note: Notice how we haven’t done anything with our class yet. We will do that next.

Step 8:

Instantiate/create your object
Classes are the blueprints/templates of php objects. Classes don’t actually become objects until you do something called: instantiation.
When you instantiate a class, you create an instance of it … thus creating the object.
In other words, instantiation is the process of creating an instance of an object in memory. What memory? The server’s memory of course!
<?php include("class_lib.php"); ?>
<?php 
 $stefan = new person();
?>
Note:  The variable $stefan becomes a handle/reference to our newly created person object. I call $stefan a ‘handle’, because we will use $stefan to control and use the person object.
If you run the PHP code now, you will not see anything displayed on your pages. The reason for this, is because we have not told PHP to do anything with the object we just created …

Step 9:

The ‘new’ keyword
To create an object out of a class, you need to use the ‘new’ keyword.
When creating/instantiating a class, you can optionally add brackets to the class name, as I did in the example below. To be clear, you can see in the code below how I can create multiple objects from the same class.
… From the PHP’s engine point of view, each object is its own entity.  Does that make sense?
<?php include("class_lib.php"); ?>
<?php 
 $stefan = new person();
 $jimmy = new person;
?>
Note:  When creating an object, be sure not to quote the class name.
For example:
$stefan = new 'person';
… will give you an error.

Step 10:

Set an objects properties
Now that we’ve created/instantiated our two separate ‘person’ objects, we can set their properties using the methods (the setters) we created.
Please keep in mind that though both our person objects ($stefan and $jimmy) are based on the same ‘person’ class, as far as php is concerned, they are totally different objects.
<?php include("class_lib.php"); ?>
<?php 
 $stefan = new person();
 $jimmy = new person;
 $stefan->set_name("Stefan Mischook");
 $jimmy->set_name("Nick Waddles");
?>

Step 11:

Accessing an object’s data
Now we use the getter methods to access the data held in our objects … this is the same data we inserted into our objects using the setter methods.
When accessing methods and properties of a class, you use the arrow  (->) operator.
<?php include("class_lib.php"); ?>
<?php 
 $stefan = new person();
 $jimmy = new person;
 
 $stefan->set_name("Stefan Mischook");
 $jimmy->set_name("Nick Waddles");
 
 echo "Stefan's full name: " . $stefan->get_name();
 echo "Nick's full name: " . $jimmy->get_name(); 
?>
Note: The arrow operator (->) is not the same operator used with associative arrays: =>.
Congratulations, you’ve made it half way through the tutorial! Time to take a little break and have some tea … OK, maybe some beer.
In a short period of time, you’ve:
  • Designed a PHP class.
  • Generate/created a couple of objects based on your class.
  • Inserted data into your objects.
  • Retrieved data from your objects.
Not bad for your first day on the OO PHP job.
If you haven’t already, now is a great time to write out the code and watch it in action in your own PHP pages.

Step 12:

Directly accessing properties – don’t do it!
You don’t have to use methods to access objects properties; you can directly get to them using the arrow operator (->) and the name of the variable.
For example: with the property $name (in object $stefan) you could get its value like so:
$name = $stefan->name;
Though doable, it is considered bad practice to do it because it can lead to trouble down the road. You should use getter methods instead – more on that later.
<?php include("class_lib.php"); ?>  
<?php 
 $stefan = new person();  
 $jimmy = new person;
 
 $stefan->set_name("Stefan Mischook");
 $jimmy->set_name("Nick Waddles"); 
 
 // directly accessing properties in a class is a no-no.
 echo "Stefan's full name: ".$stefan->name;
?>

Step 13:

Constructors
All objects can have a special built-in method called a ‘constructor’. Constructors allow you to initialise your object’s properties (translation: give your properties values,) when you instantiate (create) an object.
Note: If you create a __construct() function (it is your choice,) PHP will automatically call the __construct() method/function when you create an object from your class.
The ‘construct’ method starts with two underscores (__) and the word ‘construct’.
<?php   
 class person {
  var $name;
  function __construct($persons_name) {  
   $this->name = $persons_name;  
  }  
 
  function set_name($new_name) {
     $this->name = $new_name;
  } 
 
  function get_name() {  
     return $this->name;  
   }  
 
 }   
?>
For the rest of this tutorial, I’m going to stop reminding you that:
  • Functions = methods
  • Variables = properties
Since this is an OO PHP tutorial, I will now use the OO terminology.

Step 14:

Create an object with a constructor
Now that we’ve created a constructor method, we can provide a value for the $name property when we create our person objects.
You ‘feed’ the constructor method by providing a list of arguments (like you do with a function) after the class name.
For example:
$stefan = new person("Stefan Mischook");
This saves us from having to call the set_name() method reducing the amount of code. Constructors are common and are used often in PHP, Java etc.
<?php include("class_lib.php"); ?>  
<?php 
 $stefan = new person("Stefan Mischook");
 echo "Stefan's full name: ".$stefan->get_name();
?>
This is just a tiny example of how the mechanisms built into OO PHP can save you time and reduce the amount of code you need to write. Less code means fewer bugs.

Step 15:

Restricting access to properties using ‘access modifiers’
One of the fundamental principles in OOP is ‘encapsulation’. The idea is that you create cleaner better code, if you restrict access to the data structures (properties) in your objects.
You restrict access to class properties using something called ‘access modifiers’. There are 3 access modifiers:
  1. public
  2. private
  3. protected
‘Public’ is the default modifier.
<?php   
 class person {  
 var $name;  
  public $height;  
  protected $social_insurance;
  private $pinn_number;
 
  function __construct($persons_name) {  
   $this->name = $persons_name;  
  }  
 
  function set_name($new_name) {    
   $this->name = $new_name;
  } 
 
  function get_name() {
   return $this->name;
  }  
 
 }
?>
Note: When you declare a property with the ‘var’ keyword, it is considered ‘public’.

Step 16:

Restricting access to properties: part 2
When you declare a property as ‘private’, only the same class can access the property.
When a property is declared ‘protected’, only the same class and classes derived from that class can access the property – this has to do with inheritance …more on that later.
Properties declared as ‘public’ have no access restrictions, meaning anyone can access them.
To help you understand this (probably) foggy aspect of OOP, try out the following code and watch how PHP reacts. Tip: read the comments in the code for more information:
<?php include("class_lib.php"); ?>
<?php  
 $stefan = new person("Stefan Mischook");   
 echo "Stefan's full name: " .  $stefan->get_name() ;  
 
 /*  
 Since $pinn_number was declared private, this line of code 
 will generate an error. Try it out!   
 */  
 
 echo "Tell me private stuff: ".$stefan->pinn_number;  
?>
Note: If you try to access a private property/variable outside of the class, you will get this:
'Fatal error: Cannot access private property person::$pinn_number in ...'

Step 17:

Restricting access to methods
Like properties, you can control access to methods using one of the three
access modifiers:
  1. public
  2. protected
  3. private
Why do we have access modifiers?
In a nutshell: it comes down to control -it is makes sense to control how people use classes.
The reasons for access modifiers and other OO constructs, can be tricky to understand … especially since we are just beginners here. So give yourself a chance!
That said, we can (summarize and) say that many OOP constructs exist with idea the many programmers may be working together on a project.
<?php 
 class person {  
  var $name;  
 
  public $height;  
  protected $social_insurance;  
  private $pinn_number;
 
  function __construct($persons_name){   
     $this->name = $persons_name;  
  }       
 
  private function get_pinn_number(){
   return
   $this->pinn_number;  
  }       
 }   
?>
Notes: Since the method get_pinn_number() is ‘private’, the only place you can use this method is in the same class – typically in another method. If you wanted to call/use this method directly in your PHP pages, you would need to declare it ‘public’.
Nerd Note: Again, it is important (as we go along,) that you actually try the code yourself. It makes a HUGE difference!

Step 18:

Inheritance – reusing code the OOP way
Inheritance is a fundamental capability/construct in OOP where you can use one class, as the base/basis for another class … or many other classes.
Why do it?
Doing this allows you to efficiently reuse the code found in your base class.
Say, you wanted to create a new ’employee’ class … since we can say that ’employee’ is a type/kind of ‘person’, they will share common properties and methods.
… Making some sense?
In this type of situation, inheritance can make your code lighter … because you are reusing the same code in two different classes. But unlike ‘old-school’ PHP:
  1. You only have to type the code out once.
  2. The actual code being reused, can be reused in many (unlimited) classes
    but it is only typed out in one place … conceptually, this is sort-of
    like PHP includes().
Take a look at the sample PHP code:
// 'extends' is the keyword that enables inheritance
class employee extends person 
{
 function __construct($employee_name) {
  $this->set_name($employee_name);
 }
}

Step 19:

Reusing code with inheritance: part 2
Because the class ’employee’ is based on the class ‘person’, ’employee’ automatically has all the public and protected properties and methods of ‘person’.
Nerd note: Nerds would say that ’employee’ is a type of person.
The code:
class employee extends person 
{
 function __construct($employee_name){
  $this->set_name($employee_name);
 }
}
Notice how we are able to use set_name() in ’employee’, even though we did not declare that method in the ’employee’ class. That’s because we already created set_name() in the class ‘person’.
Nerd Note: the ‘person’ class is called (by nerds,) the ‘base’ class or the ‘parent’ class because it’s the class that the ’employee’ is based on. This class hierarchy can become important down the road when your projects become more complex.

Step 20:

Reusing code with inheritance: part 3
As you can see in the code snippet below, we can call get_name on our ’employee’ object, courtesy of ‘person’.
The code:
 <?phpinclude("class_lib.php"); ?>
 <?php
  // Using our PHP objects in our PHP pages. 
  $stefan = new person("Stefan Mischook");
  echo "Stefan's full name: " . $stefan->get_name();
 
  $james = new employee("Johnny Fingers");
  echo "---> " . $james->get_name();
 ?>
This is a classic example of how OOP can reduce the number of lines of code (don’t have to write the same methods twice) while still keeping your code modular and much easier to maintain.

Step 21:

Overriding methods
Sometimes (when using inheritance,) you may need to change how a method works from the base class.
For example, let’s say set_name() method in the ’employee’ class, had to do something different than what it does in the ‘person’ class.
You ‘override’ the ‘person’ classes version of set_name(), by declaring the same method in ’employee’.
The code snippet:
<?php
 class person 
 {
  protected function set_name($new_name) {
   if ($new_name != "Jimmy Two Guns") {
    $this->name = strtoupper($new_name);
   }
  }
 } 
 
 class employee extends person 
 {
  protected function set_name($new_name) {
   if ($new_name == "Stefan Sucks") {
    $this->name = $new_name;
   }
  }
 }
?>
Notice how set_name() is different in the ’employee’ class from the version found in the parent class: ‘person’.

Step 22:

Overriding methods: part 2
Sometimes you may need to access your base class’s version of a method you overrode in the derived (sometimes called ‘child’) class.
In our example, we overrode the set_name() method in the ’employee’ class. Now I’ve used this code:
person::set_name($new_name);
… to access the parent class’ (person) version of the set_name() method.
The code:
<?php
 class person 
 {
  // explicitly adding class properties are optional - but 
  // is good practice
  var $name;  
  function __construct($persons_name) {
   $this->name = $persons_name;
   }
 
   public function get_name() {
    return $this->name;
   }
 
   // protected methods and properties restrict access to 
   // those elements.
   protected function set_name($new_name) {
     if ($this->name !=  "Jimmy Two Guns") {
      $this->name = strtoupper($new_name);
     } 
  }
 } 
 
 // 'extends' is the keyword that enables inheritance
 class employee extends person 
 {
  protected function set_name($new_name) {
  if ($new_name ==  "Stefan Sucks") {
   $this->name = $new_name;
  }
   else if ($new_name ==  "Johnny Fingers") {
   person::set_name($new_name);
  } 
 }
 
 function __construct($employee_name) 
 {
  $this->set_name($employee_name);
 }
}
?>
Notes: Using the symbol:
::
… allows you to specifically name the class where you want PHP to search for a method:
'person::set_name()'
… tells PHP to search for set_name() in the ‘person’ class.
There is also a shortcut if you just want refer to current class’s parent – by using the ‘parent’ keyword.
The code:
protected function set_name($new_name) 
{ 
 if ($new_name ==  "Stefan Sucks") {
  $this->name = $new_name; 
  } 
  else if ($new_name ==  "Johnny Fingers") {
  parent::set_name($new_name); 
 } 
}

Conclusion

We’ve only touched on the basics of OO PHP. But you should have enough information to feel comfortable moving forward.
Remember that the best way to really have this stuff sink in, is by actually writing code.
I would suggest creating say 10 simple objects that do simple things, and then use those objects in actual PHP pages. Once you’ve done that, you will feel very comfortable with objects.
If you guys/gals are interested in more, let me know.

Tuesday, February 23, 2016

Saturday, July 11, 2015

Anna University Recruitment 2015 annauniv.edu Asst/Faculty Posts

Anna University Recruitment

Anna University has circulated an advertisement regarding Anna University Recruitment. The applications are invited from the capable and talented job hunters to fill up the Assistant Professor, College Director posts. Aspirants who want to apply for Anna University Recruitment 2015 must fill the application form on or before the closing date that is 31st July 2015.
Name of Posts Assistant Professor, Librarian, College Director
Vacancy 138
Last date to apply 31st July 2015
Eligible contenders can get all details associated with Anna University Recruitment 2015 from this page. Just scroll it and read below mentioned details which are given by the team members of recruitmentresult.com.  The institute is looking for aspirants who had required qualification and potential to work hard. So, if you are one amongst them, then don’t wait any more ,apply for Anna University jobs 2015 before closing date of this employment notification.
Post and vacancy Details:
Post Name Vacancy
Assistant Professor
Civil engineering 39
Mechanical engineering 38
Electronics and communication engineering 20
Electrical and electronics engineering 15
College librarian
Library 15
College Director
Physical education 11
Educational Qualification:

Candidates who are willing to apply for this recruitment they must have done post graduate degree in respective e discipline from a recognized university / Institute.
]

Friday, April 24, 2015

Sunday, April 12, 2015

Display Superscript text as data series on chart

Display Superscript text as data series on chart

enter image description here
If can only copy-paste following characters (including letters) in superscript and subscript. Do it in your Excel file.
Consolidated for cut-and-pasting purposes, the Unicode standard defines complete sub- and super-scripts for:
  • numbers and common mathematical symbols ( ⁰ ¹ ² ³ ⁴ ⁵ ⁶ ⁷ ⁸ ⁹ ⁺ ⁻ ⁼ ⁽ ⁾ ₀ ₁ ₂ ₃ ₄ ₅ ₆ ₇ ₈ ₉ ₊ ₋ ₌ ₍ ₎ )
  • a full superscript Latin lowercase alphabet except q ( ᵃ ᵇ ᶜ ᵈ ᵉ ᶠ ᵍ ʰ ⁱ ʲ ᵏ ˡ ᵐ ⁿ ᵒ ᵖ ʳ ˢ ᵗ ᵘ ᵛ ʷ ˣ ʸ ᶻ )
  • a limited uppercase Latin alphabet ( ᴬ ᴮ ᴰ ᴱ ᴳ ᴴ ᴵ ᴶ ᴷ ᴸ ᴹ ᴺ ᴼ ᴾ ᴿ ᵀ ᵁ ⱽ ᵂ ) - no C, F, Q, S, X, Y, Z
  • a few subscripted lowercase letters ( ₐ ₑ ₕ ᵢ ₖ ₗ ₘ ₙ ₒ ₚ ᵣ ₛ ₜ ᵤ ᵥ ₓ )
  • and some Greek letters ( ᵅ ᵝ ᵞ ᵟ ᵋ ᶿ ᶥ ᶲ ᵠ ᵡ ᵦ ᵧ ᵨ ᵩ ᵪ ).
Note that since these glyphs come from different ranges, they may not be of the same size and position, depending on the typeface.

Thursday, January 22, 2015

New 3D Printers Could Build Implants, Electronics

Several new 3D printers showcased at CES 2015 in Las Vegas earlier this month suggest that the 3D printing industry — best known for churning out brightly colored plastic doodads — could be turning over a new, more scientific leaf.
Amid the rough-edged replicas of superheroes and army tanks that adorned the expo's 3D printingspace stood a machine that prints tiny medical implants that dissolve inside the human body. Another printer uses a combination of conductive inks and filaments to print quadcopters already embedded with the electronics that allow them to hover in the air. One company displayed a prototype of a 3D-printed medical device that can automatically stitch up patients after surgery.
The message these companies are sending couldn't be clearer: 3D printing isn't just for makers anymore. Increasingly, this trendy technology is turning into a must-have tool for doctors, researchers and engineers, according to Nick Liverman, CEO and founder of Old World Labs (OWL), a Virginia-based company that designs dissolvable 3D-printed implants. [The 10 Weirdest Things Created By 3D Printing]








OWL's MC-1 and MC-2 printers were both on display at CES. The machines use a process known as stereolithography (SLA), in which lasers harden layers of liquid plastic, or resin, into three-dimensional shapes. This technique sets OWL's printers apart from other 3D printers on the market, such as MakerBot's Replicator or the Ultimaker 2, that use a process known as fused deposition modeling (FDM), not SLA.
OWL's 3D Printer.

This 3D printer by Old World Labs (OWL) prints objects in very fine detail, making it a good tool for researchers and engineers.
Credit: Old World Labs
In FDM, heated plastic is released layer by layer onto a platform to create a 3D object, a process that results in a much less detailed product with a rougher finish than objects created using SLA. Other 3D printers on the market also usestereolithography to build what Liverman calls "high-resolution" objects. But OWL's machines are more advanced than these printers, according to Liverman, who said that his company's machines print objects that are 200 times more accurate, or truer to their original design, than objects created with other SLA printers.
OWL is currently using its super-accurate printers to bring complex ideas to life. For example, cancer researchers who want to deliver localized treatments to patients are using OWL's machines to build what Liverman called "microfluidic devices." Such devices are highly detailed, containing tiny channels that circulate prescription drugs into a patient's body.
"You can also build custom implants, like tissue scaffolds," Liverman said. "You can inject stem cells into the scaffold that you build with the printer and then you can, for example, do a cartilage replacement on a knee." [7 Cool Uses of 3D Printing in Medicine]
During cartilage replacement surgery, the scaffold containing the stem cells would be implanted in the knee, where the stem cells grow to replace the missing cartilage, Liverman said. The scaffold, which is printed with what Liverman called "bioreabsorbable material," eventually dissolves harmlessly inside the body. OWL is currently working on obtaining long-term FDA approval for the resins used in its printing process. This would allow the company's clients, which include NASA and Virginia Tech, to print such scaffolds and other medical-grade devices and use them in real-world settings, not just in the lab.
Printable electronics
OWL wasn't the only progressive 3D printing company hawking its wears at CES. Harvard-based startup Voxel8 was there, too. The company's 3D printers have two extruders — one that prints in conventional plastic filaments and another that squirts out highly conductive ink.
"Coming off the printer is not just a plastic shape but a fully functioning electronic device," said Voxel8 co-founder Daniel Oliver.
At CES, Voxel8 showed off a quadcopter printed with its machine. The flying toy was built in layers — the structure of the device was printed in plastic with cavities carved out for the control logic board and the motors. The printer then used conductive ink (which takes the place of wires) on top of the plastic, connecting these electrical components. The ink, along with the imbedded electronics, eventually got covered up with more layers of plastic.
3D printed quadcopter.

This small drone was printed with Voxel8's 3D printer.
Credit: Voxel8
Of course, Voxel8's printer is designed to do more than just print tiny drones. The company will also be releasing new printing materials in order to try its hand at printing resistors, sensors and, for future models of its printer, even lithium-ion batteries. These objects are in addition to the custom circuit boards that Voxel8's printers have already perfected.
"We're talking about printing out a circuit at your desk in less than 30 minutes," Oliver said. This represents a vast improvement over earlier options for printing custom circuit boards, a process that, Oliver said, traditionally could take up to a month to complete.
Engineers and developers will not only be able to realize their designs much quicker with a Voxel8 printer, they'll also be able to try out unconventional geometries for their electronics, Oliver said. For example, rather than trying to get a rectangular circuit board to fit inside a curved object, it will now be possible to customize the shape of a circuit so that it fits inside objects of any shape or size.
"There's a trend to try to get 3D printing to create more useful things," Oliver told Live Science. "[We're] getting closer and closer to the idea that anything can be 3D printed."

Wednesday, January 21, 2015

Big Data: 6 bold predictions for 2015


'Tis the season when industry soothsayers don their prognostication caps to make fearless forecasts for the coming year. What does the crystal ball say about big data?



We culled an assortment of 2015 predictions from big data executives and analysts. The overarching theme: Big data gets real next year, as does the Internet of Things. What do you think? Will these prophecies come true, or are better suited for the Psychic Friends Network?

Prediction #1: Big data proves it's more than just big hype. "In 2014 the booming ecosystem around Hadoop was celebrated with a proliferation of applications, tools, and components. In 2015, the market will concentrate on the differences across platforms and the architecture required to integrate Hadoop into the data center and deliver business results." -- MapR CEO and cofounder John Schroeder.

Prediction #2: On a similar note, 2015 will be Hadoop's "show me the money" year. "Hadoop has been rapidly adopted as 'the way' to execute any go-forward data strategy. However, early adopters must now show return on investment, whether it's migrating workloads from legacy systems or new data applications. Luckily, products and tools are evolving to keep pace with the trajectory of Hadoop." -- Gary Nakamura, CEO of Concurrent.
Prediction #3: Location services move indoors. "Indoor location technology and services will rapidly gain traction. Where previously WiFi was the primary enabler to position a mobile device indoors, its inability to calculate elevation, coupled with errors introduced through signal noise, has meant that using WiFi alone indoors was frequently not accurate enough. However, with BLE (Bluetooth Low Energy) beacons now increasing in number, these can combine with WiFi access points while using the device-embedded MEMS (Micro-electro-mechanical-systems) sensors to provide accurate location indoors." -- Juniper Research's "Top 10 Tech Trends for 2015" whitepaper.

 Prediction #4: Connected cars might grab the headlines, but other IoT devices will prove a lot more useful.    "Autonomous vehicles such as drones and self-driving cars will dominate public perception of the IoT. Less-glamorous connected objects will make the greatest impact on people's lives -- many without them even knowing it." -- Brian Gilmore, an Internet of Things and industrial data expert at Splunk

Prediction #5: You, too, can be a data scientist, no PhD required. "As data becomes more accessible and analytic tools become easier to use and readily available, data science won't be limited to those in the technology sector. In 2015, anyone with the right tools can draw powerful insights from data. "We're not blasting CS degrees but in 2015, data scientists' skillsets will be vastly different, especially as the ability to code will be less of a job requirement. Data scientists should take a page out of anthropology and understand that qualitative information can also provide answers to questions you didn't know you had." -- Lukas Biewald, CEO and cofounder of CrowdFlower, a data-mining and crowdsourcing service.

 Prediction #6: The Internet of Things will have a big impact on customer service, with consumers expecting more personalized interaction with vendors. "The Internet of Things changes the entire customer service dynamic; rather than a limited number of customer communication channels, customer experience management (CEM) systems will be able to process live streams of data from fitness wearables, motor vehicles, home appliances, and medical instruments, to name only a few categories of connected devices on the horizon. When collected, correlated, and applied, the data from these devices will coalesce into an unprecedented view of the customer's needs, resulting in far greater competitive advantage for those who are aware of the possibilities." -- Keith McFarlane, CTO and senior vice president of engineering at LiveOps, a cloud-based customer service provider.