₦airaland Forum

Khaynet:
ok.....whats d time range

The time range is from when you send me the link to your app or website, until you close or end your app/website. Once you have active users, you have them for life.

Khaynet:
shey no b spam traffic

Definitely, no spam traffic. Like I said in Step 3, when u feel satisified with my service, then u can pay me.

Infohelp:
how will u do that?

3 Easy Steps.

Step 1 - Give Me A Link To Your App/Website
Step 2 - Check Your App Downloads Or Website Traffic
Step 3 - Pay Me When You Feel Satisfied With My Service.

Khaynet:
how

3 Easy Steps.

Step 1 - Give Me A Link To Your App/Website
Step 2 - Check Your App Downloads Or Website Traffic
Step 3 - Pay Me When You Feel Satisfied With My Service.

I'll get you 1,000 Active users for 1,000 Naira. Or for each user you get, you pay 1 Naira. So 500 Active Users from me, will cost you 500 Naira.

I have 3 Android & J2ME Popular Games For N3,000. The 3 games come with the source code and are very well known in the market.

SignalR is one of those libraries that I first experienced back in 2012 at my second Codemash. Scott Hanselmann gave a brief overview of the library in one of his sessions and I looked over to one of my friends and said, "Man, SignalR sounds like a game-changer...I wish there was a session on THAT."

I checked out the schedule and BAM...there was a session about SignalR the next day.

Needless to say, I was extremely excited to start digging into the library and learn how to apply SignalR to existing projects.

Since then, SignalR has definitely made it's way into the Microsoft world. It's even used in the Web Essentials extension for updating a web page through Visual Studio when you make a change to CSS or HTML. You immediately see it update in the browser.

In this post, we'll walk-through a simple example of building a "Did you like this post?" widget using SignalR.

What is SignalR?
SignalR is a server-side library to add real-time functionality to your existing web applications. This also includes the ability to push notifications out to the client as they happen.

SignalR takes advantage of multiple protocols when determining how to send and receive data. First, it determines if it can use WebSockets, an HTML5 protocol. If that doesn't work then it gracefully falls back to older technology to make sure it works.

For more detailed information about how SignalR determines which technology to use, head to the Introduction to SignalR page at Microsoft.

Original Post - http://www.danylkoweb.com/Blog/how-to-make-your-own-real-time-like-button-using-aspnet-mvc-jquery-and-signalr-QF

Welcome to this new series of JavaScript tutorials. It is designed for developers who are experienced with other programming languages (C++ or even worst : Java) and who think that JavaScript is a light version of Java: its name starts with Java and it even has a similar syntax which is definitely wrong. I was one day one of these guys. I always had the following issue when writing in JavaScript: I start coding quickly. It’s exactly the same thing to what I use to. What’s the worst that can happen? And then when I run the code, I discover a countless number of bugs for reasons that I don’t understand. Sometimes, even worst: the whole architecture of my code is wrong because I didn't understand how JavaScript works and I need to start from scratch. (I still have yet some of these issues ☺).
Through this series we are going to discuss the dark parts of JavaScript: the parts where I got most of the troubles.



The Scope



Global Variables
A global variable can be accessed and modified outside and inside the function where it was defined.

A variable which is declared outside a function with “var” is a global variable.

var a;
a = 1;
alert(a); // a = 1
function test(){
alert(a); // a = 1
a = 5;
}
test();
alert(a); // a = 5
Warning!!
A variable which is declared inside or even outside a function without using a “var” is also a global variable.

function test(){
a = 5;
}
test();
alert(a); // a = 5


Local Variables
A local variable can be accessed and modified only inside the function where it was defined.

A variable which is declared inside a function with a “var” is a local variable.

function test(){
var a = 5;
}
test();
alert(a); // ReferenceError: a is not defined.
Function arguments are also local variables.

function test(a){
alert(a); // a = 5
}
test(5);
alert(a); // ReferenceError: a is not defined.


Local vs Global
When there are two variables: one is local and the other one is global and both have the same name, the local variable hides the global variable.

var a;
a = 1;
alert(a); // a = 1
function test(){
var a = 5;
alert(a); // a = 5
a = 4;
}
test();
alert(a); // a = 1


Block Scope
There is no bock scope in JavaScript.

var a;
a = 1;
alert(a); // a = 1
function test(){
if(true) {
var a = 5;
}
alert(a); // a = 5
a = 4;
}
test();
alert(a); // a = 1
Actually

Conclusion
The main conclusion of this article is that the JavaScript scope is different to other programming languages like Java/C++ that we are used to.

So please be careful about that and try to understand all these rules to avoid later a lot of bugs.

Original Post - https://medium.com/@riadh/javascript-the-dark-parts-scope-6172c90bff11

Hopping between my open-source Android projects and Photoshop Elements at Adobe involves a lot of mental context-switching. A majority of that transition is necessitated by the fact that Java and C++ share similar syntax and semantics but differ in countless ways, often subtly. I often catch myself "thinking in Java" when writing C++, or the other way around, when I'm in the midst of said context-switch.

The other thing to consider is: C++ is a double-edged sword. It's powerful, but that also makes it very easy to make mistakes.

So I thought I'd compile a list of common C++ pitfalls / things to remember / things I find interesting, with references to more detailed discussions. I expect to often refer to this post myself. The format is somewhat terse, so beginners might find it confusing.

1. delete heap memory
I know you don't need me to tell you this. But sometimes I forget to call delete (or delete[]), so this item is basically a reminder for myself. It doesn't help that accidentally calling vanilla delete on new[]'ed memory causes undefined behaviour, potentially including subtle memory leaks.

2. never throw from a destructor
Yes, I hear you: "But what if my destructor fails?". Simmer down, whippersnapper. I'm calling in the cavalry on this one. Here's Marshall Cline's suggestion (Cline is author of the treasured C++ FAQ):

Write a message to a log-file. Or call Aunt Tilda. But do not throw an exception!
You at least trust him, if not me, right? You should. Here's the reason: when an exception is being processed, the program begins moving up the call stack in search of a catch block, popping off stack frames and destroying all local objects in them. Guess what happens if the destructor of one those objects throws an exception? Now there are two uncaught exceptions to deal with, and no catch in sight! At this point the program simply explodes in your face, as the realization dawns that you've committed thrown one sin exception too many in the Holy Land of C++.

3. declare base class destructors as virtual
class A {
~A() { ... }
};

class B : public A {
~B() { ... }
};

A *a = new B();
delete a; // what happens here?
The call to delete at the end will, in most cases, call A::~A(), resulting in a hard-to-detect memory leak. The standard's stance on this issue is "undefined behaviour". Making A's destructor virtual resolves the leak.

4. always catch references, not values or pointers
Spot the best code:

// option 1
try { ... }
catch (exception e) { ... }

// option 2
try { ... }
catch (exception& e) { ... }

// option 3
try { ... }
catch (exception* e) { ... }
Yes, yes, it's option 2. But why?

Option 1 is bad because: (a) it might involve an unnecessary copy constructor invocation, and (b) it can cause a subtle bug, thanks to slicing! For example, if the try block throws an instance of type derived_exception, derived from the type exception (duh), then the latter's copy constructor gets called, resulting in a hacked-off instance of the former getting sliced into the latter.

Option 3 is bad simply because naked pointers need to be manually de-allocated. This is especially bad considering the fact that when I'm writing a catch block, I already have a lot to think about: how to recover from the massive shit-storm I just got into, whether I can punt responsibility up the call stack, and so on. So no naked pointers to exceptions, thank you very much.

5. char const* const buffer
const follows a rather simple rule: it acts on whatever precedes it. So:

char const* buffer; // pointer to const char (1)
char* const buffer; // const pointer to char (2)
char const* const buffer; // const pointer to const char (3)
Much of the confusion arises because many (including me) tend to prefer placing the const before the char in the first case:

const char* buffer; // pointer to const char, same as (1)
If you'll tolerate my hypocrisy for a moment, here's my suggestion: try to avoid putting the const at the beginning like that. Another source of confusion is array declarations with const:

int main(int argc, char* const* argv); // pointer to const pointer to char
int main(int argc, char* const argv[]); // equivalent
6. copy constructor signature
What's the right signature for a copy constructor?

A::A(A) - infinite recursion
A::A(A& - valid but won't work if the argument is a temporary, e.g., A fn() { A a1; return a1; }; A a2 = fn(); // error
A::A(const A& - valid and works with temporaries (see item #
7. return value of operator=
Consider the overridden assignment operator for class A (our favourite class):

A::operator=(const A& other) { // guess the return type?
// assign other to this
// ...

return ; // what to return here?
}
The standard says the return type of operator= must be A& and the return value "a reference to the left hand operand", i.e., *this. Without a satisfactory reason, that's just begging to be forgotten. Here's your reason: it's so that chained assignments like a = b = c work correctly (think of it as a.operator=(b.operator=(c))).

8. temporary objects can only bind to const references
A getA() { return A(); }
const A &a = getA(); // ok
A &a = getA(); // error
You cannot assign temporaries to non-const references. You knew that right? Yes, I'm looking at you, Visual Studio 2010 user. Your compiler doesn't even emit a measly warning for decidedly non-standard behaviour. Clang and GCC are kind enough to spit out descriptive compilation errors. This has bitten me more than once, when writing cross-platform code in Visual Studio.

9. the parentheses in new A() matter more than you think they do
class A { int n; };
A a1 = new A();
A a2 = new A;
What do you think are the values of a1.n and a2.n right after construction? Answer: 0 and {insert garbage value here}. More generally, plain old datatypes are zero-initialized in the former case, but behaviour in the latter case is implementation-defined.

10. dynamic_cast works only with runtime polymorphic types
Sure, your compiler helps you out with this. But this is very easy to forget, say, in an interview. So have you thought about why at least one virtual function is needed for using dynamic_cast? Simply because it's convenient to implement dynamic_cast by piggy-backing on the virtual method infrastructure: the type hierarchy information (conventionally called "run-time type information" or "RTTI" is usually attached to the vtable, and a run-time check is performed, using available RTTI, to determine whether the cast is valid.

Original Post - http://vickychijwani.me/cpp-gotchas/

About this guide

Hi, I am Felix Geisendörfer, an early node.js core contributor and co-founder of transloadit.com.

Over the past few months I have given a lot of talks and done a lot of consulting on using node.js.

Since I found myself repeating a lot of things over and over, I decided to use some of my recent vacation to start this opinionated and unofficial guide to help people getting started in node.js.

Original Post - http://nodeguide.com/

Yeah, I feel you. I've seen alot of Node.js and Angular.js stuff, but I didn't know if people were interested. By the way, can somebody please tell me what is the difference between a web designer, a web developer and a web programmer?

Interested in landing a job as a data scientist? You’re in good company - a recent article by Thomas Davenport and D.J. Patil in the Harvard Business Review calls ‘data scientist’ the sexiest job of the 21st century.

But how can you get your foot in the door? Many resources out there may lead you to believe that becoming a data scientist requires comprehensive mastery of a number of fields, such as software development, data munging, databases, statistics, machine learning and data visualization.

Don’t worry. In my experience as a data scientist, that’s not the case. You don’t need to learn a lifetime’s worth of data-related information and skills as quickly as possible. Instead, learn to read data science job descriptions closely. This will enable you to apply to jobs for which you already have necessary skills, or develop specific data skill sets to match the jobs you want.

This is the core set of 8 data science competencies you should develop:

Basic Tools: No matter what type of company you’re interviewing for, you’re likely going to be expected to know how to use the tools of the trade. This means a statistical programming language, like R or Python, and a database querying language like SQL.

Basic Statistics: At least a basic understanding of statistics is vital as a data scientist. An interviewer once told me that many of the people he interviewed couldn’t even provide the correct definition of a p-value. You should be familiar statistical tests, distributions, maximum likelihood estimators, etc. Think back to your basic stats class! This will also be the case for machine learning, but one of the more important aspects of your statistics knowledge will be understanding when different techniques are (or aren’t) a valid approach. Statistics is important at all company types, but especially data-driven companies where the product is not data-focused and product stakeholders will depend on your help to make decisions and design / evaluate experiments.

Machine Learning: If you’re at a large company with huge amounts of data, or working at a company where the product itself is especially data-driven, it may be the case that you’ll want to be familiar with machine learning methods. This can mean things like k-nearest neighbors, random forests, ensemble methods - all of the machine learning buzzwords. It’s true that a lot of these techniques can be implemented using R or Python libraries - because of this, it’s not necessarily a dealbreaker if you’re not the world’s leading expert on how the algorithms work. More important is to understand the broadstrokes and really understand when it is appropriate to use different techniques.

Multivariable Calculus and Linear Algebra: You may in fact be asked to derive some of the machine learning or statistics results you employ elsewhere in your interview. Even if you’re not, your interviewer may ask you some basic multivariable calculus or linear algebra questions, since they form the basis of a lot of these techniques. You may wonder why a data scientist would need to understand this stuff if there are a bunch of out of the box implementations in sklearn or R. The answer is that at a certain point, it can become worth it for a data science team to build out their own implementations in house. Understanding these concepts is most important at companies where the product is defined by the data and small improvements in predictive performance or algorithm optimization can lead to huge wins for the company.

Data Munging: Often times, the data you’re analyzing is going to be messy and difficult to work with. Because of this, it’s really important to know how to deal with imperfections in data. Some examples of data imperfections include missing values, inconsistent string formatting (e.g., ‘New York’ versus ‘new york’ versus ‘ny’), and date formatting (‘2014-01-01’ vs. ‘01/01/2014’, unix time vs. timestamps, etc.). This will be most important at small companies where you’re an early data hire, or data-driven companies where the product is not data-related (particularly because the latter has often grown quickly with not much attention to data cleanliness), but this skill is important for everyone to have.

Data Visualization & Communication: Visualizing and communicating data is incredibly important, especially at young companies who are making data-driven decisions for the first time or companies where data scientists are viewed as people who help others make data-driven decisions. When it comes to communicating, this means describing your findings or the way techniques work to audiences, both technical and non-technical. Visualization wise, it can be immensely helpful to be familiar with data visualization tools like ggplot and d3.js. It is important to not just be familiar with the tools necessary to visualize data, but also the principles behind visually encoding data and communicating information.

Software Engineering: If you’re interviewing at a smaller company and are one of the first data science hires, it can be important to have a strong software engineering background. You’ll be responsible for handling a lot of data logging, and potentially the development of data-driven products.

Thinking Like A Data Scientist: Companies want to see that you’re a (data-driven) problem solver. That is, at some point during your interview process, you’ll probably be asked about some high level problem - for example, about a test the company may want to run or a data-driven product it may want to develop. It’s important to think about what things are important, and what things aren’t. How should you, as the data scientist, interact with the engineers and product managers? What methods should you use? When do approximations make sense?

Data science is still nascent and ill-defined as a field. Getting a job is as much about finding a company whose needs match your skills as it is developing those skills. This writing is based on my own firsthand experiences - I’d love to hear if you’ve had similar (or contrasting) experiences during your own process.

Original Post - http://blog.udacity.com/2014/11/data-science-job-skills.html

We describe the first direct brain-to-brain interface in humans and present results from experiments involving six different subjects. Our non-invasive interface, demonstrated originally in August 2013, combines electroencephalography (EEG) for recording brain signals with transcranial magnetic stimulation (TMS) for delivering information to the brain. We illustrate our method using a visuomotor task in which two humans must cooperate through direct brain-to-brain communication to achieve a desired goal in a computer game. The brain-to-brain interface detects motor imagery in EEG signals recorded from one subject (the “sender”) and transmits this information over the internet to the motor cortex region of a second subject (the “receiver”). This allows the sender to cause a desired motor response in the receiver (a press on a touchpad) via TMS. We quantify the performance of the brain-to-brain interface in terms of the amount of information transmitted as well as the accuracies attained in (1) decoding the sender’s signals, (2) generating a motor response from the receiver upon stimulation, and (3) achieving the overall goal in the cooperative visuomotor task. Our results provide evidence for a rudimentary form of direct information transmission from one human brain to another using non-invasive means.

Original Post - http://www.plosone.org/article/info%3Adoi%2F10.1371%2Fjournal.pone.0111332

Laptop. Give laptop.

At Mozilla we know that developers are the cornerstone of the Web, that’s why we actively push standards and continue to build great tools to make it easier for you to create awesome Web content and apps.

When building for the Web, developers tend to use a myriad of different tools which often don’t work well together. This means you end up switching between different tools, platforms and browsers which can slow you down and make you less productive.

So we decided to unleash our developer tools team on the entire browser to see how we could make your lives easier.

We’re now ready to give you a sneak peek of the first browser dedicated you as a developer:

We’ve redesigned the browser by looking at it through a completely new filter to put developers’ interests first. It’s built by developers for developers so you can debug the whole Web, allowing you to more easily build awesome Web experiences. It also integrates some powerful new tools like WebIDE and the Firefox Tools Adapter.

Soon, we’re going to bring you more, a lot more, in a package that you deserve as a builder for an independent Web.

Get ready to spread the word (#Fx10) or sign up for our Hacks newsletter here to be emailed as soon as the browser is available.

We can’t wait to share it with you on November 10th.

Original Post - https://blog.mozilla.org/blog/2014/11/03/the-first-browser-dedicated-to-developers-is-coming-2/

internetvote:
I have created this Online voting application for Nigerian at http://www.nairavote.com

Please help me test it and you can offer your suggestions and contributions for improvements

I like it but do you have any plans to make it secure it enough, that only Nigerians vote in it, as well as make sure that people don't vote twice and there are no bots or spammers vote in order to increase count for a particular party?

The big languages are popular for a reason: They offer a huge foundation of open source code, libraries, and frameworks that make finishing the job easier. This is the result of years of momentum in which they are chosen time and again for new projects, and expertise in their nuances grow worthwhile and plentiful.

FEATURED RESOURCE

Presented by Citrix Systems
10 essential elements for a secure enterprise mobility strategy
Best practices for protecting sensitive business information while making people productive from
LEARN MORE
Sometimes the vast resources of the popular, mainstream programming languages aren’t enough to solve your particular problem. Sometimes you have to look beyond the obvious to find the right language, where the right structure makes the difference while offering that extra feature to help your code run significantly faster without endless tweaking and optimizing. This language produces vastly more stable and accurate code because it prevents you from programming sloppy or wrong code.

The world is filled with thousands of clever languages that aren't C#, Java, or JavaScript. Some are treasured by only a few, but many have flourishing communities connected by a common love for the language's facility in solving certain problems. There may not be tens of millions of programmers who know the syntax, but sometimes there is value in doing things a little differently, as experimenting with any new language can pay significant dividends on future projects.

The following nine languages should be on every programmer’s radar. They may not be the best for every job -- many are aimed at specialized tasks. But they all offer upsides that are worth investigating and investing in. There may be a day when one of these languages proves to be exactly what your project -- or boss -- needs.


Erlang: Functional programming for real-time systems

Erlang began deep inside the spooky realms of telephone switches at Ericsson, the Swedish telco. When Ericsson programmers began bragging about its "nine 9s" performance, by delivering 99.9999999 percent of the data with Erlang, the developers outside Ericsson started taking notice.

Erlang’s secret is the functional paradigm. Most of the code is forced to operate in its own little world where it can't corrupt the rest of the system through side effects. The functions do all their work internally, running in little "processes" that act like sandboxes and only talk to each other through mail messages. You can't merely grab a pointer and make a quick change to the state anywhere in the stack. You have to stay inside the call hierarchy. It may require a bit more thought, but mistakes are less likely to propagate.

The model also makes it simpler for runtime code to determine what can run at the same time. With concurrency so easy to detect, the runtime scheduler can take advantage of the very low overhead in setting up and ripping down a process. Erlang fans like to brag about running 20 million "processes" at the same time on a Web server.

If you're building a real-time system with no room for dropped data, such as a billing system for a mobile phone switch, then check out Erlang.

Go: Simple and dynamic

Google wasn’t the first organization to survey the collection of languages, only to find them cluttered, complex, and often slow. In 2009, the company released its solution: a statically typed language that looks like C but includes background intelligence to save programmers from having to specify types and juggle malloc calls. With Go, programmers can have the terseness and structure of compiled C, along with the ease of using a dynamic script language.

RECENT JAVA HOW-TOs
webtools
Responsive web design with Google Web Toolkit
on target
Stability patterns applied in a RESTful architecture
ChoiceFormat: Numeric range formatting
While Sun and Apple followed a similar path in creating Java and Swift, respectively, Google made one significantly different decision with Go: The language’s creators wanted to keep Go "simple enough to hold in one programmer's head." Rob Pike, one of Go’s creators, famously told Ars Technica that "sometimes you can get more in the long run by taking things away." Thus, there are few zippy extras like generics, type inheritance, or assertions, only clean, simple blocks of if-then-else code manipulating strings, arrays, and hash tables.

The language is reportedly well-established inside of Google's vast empire and is gaining acceptance in other places where dynamic-language lovers of Python and Ruby can be coaxed into accepting some of the rigor that comes from a compiled language.

If you're a startup trying to catch Google's eye and need to build some server-side business logic, Go is a great place to start.

Groovy: Scripting goodness for Java

The Java world is surprisingly flexible. Say what you will about its belts-and-suspenders approach, like specifying the type for every variable, ending every line with a semicolon, and writing access methods for classes that simply return the value. But it looked at the dynamic languages gaining traction and built its own version that's tightly integrated with Java.

Groovy offers programmers the ability to toss aside all the humdrum conventions of brackets and semicolons, to write simpler programs that can leverage all that existing Java code. Everything runs on the JVM. Not only that, everything links tightly to Java JARs, so you can enjoy your existing code. The Groovy code runs like a dynamically typed scripting language with full access to the data in statically typed Java objects.

POPULAR ON JAVAWORLD

Java programming with lambda expressions
Hello, OSGi, Part 1: Bundles for beginners
javascript
Review: 10 JavaScript editors and IDEs put to the test
Groovy programmers think they have the best of both worlds. There's all of the immense power of the Java code base with all of the fun of using closures, operator overloading, and polymorphic iteration -- not to mention the simplicity of using the question mark to indicate a check for null pointers. It's so much simpler than typing another if-then statement to test nullity. Naturally, all of this flexibility tends to create as much logic with a tiny fraction of the keystrokes. Who can't love that?

Finally, all of the Java programmers who've envied the simplicity of dynamic languages can join the party without leaving the realm of Java.

OCaml: Complex data hierarchy juggler

Some programmers don't want to specify the types of their variables, and for them we've built the dynamic languages. Others enjoy the certainty of specifying whether a variable holds an integer, string, or maybe an object. For them, many of the compiled languages offer all the support they want.

Then there are those who dream of elaborate type hierarchies and even speak of creating "algebras" of types. They imagine lists and tables of heterogeneous types that are brought together to express complex, multileveled data extravaganzas. They speak of polymorphism, pattern-matching primitives, and data encapsulation. This is just the beginning of the complex, highly structured world of types, metatypes, and metametatypes they desire.

For them, there is OCaml, a serious effort by the programming language community to popularize many of the aforementioned ideas. There's object support, automatic memory management, and device portability. There are even OCaml apps available from Apple’s App Store.

An ideal project for OCaml might be building a symbolic math website to teach algebra.


CoffeeScript: JavaScript made clean and simple

Technically, CoffeeScript isn't a language. It's a preprocessor that converts what you write into JavaScript. But it looks different because it's missing plenty of the punctuation. You might think it is Ruby or Python, though the guts behave like JavaScript.

CoffeeScript began when semicolon haters were forced to program in JavaScript because that was what Web browsers spoke. Changing the way the Web works would have been an insurmountable task, so they wrote their own preprocessor instead. The result? Programmers can write cleaner code and let CoffeeScript turn it back into the punctuation-heavy JavaScript Web browsers demand.

Missing semicolons are only the beginning. With CoffeeScript, you can create a variable without typing var. You can define a function without typing function or wrapping it in curly brackets. In fact, curly brackets are pretty much nonexistent in CoffeeScript. The code is so much more concise that it looks like a modernist building compared to a Gothic cathedral. This is why many of the newest JavaScript frameworks are often written in CoffeeScript and compiled.

Scala: Functional programming on the JVM

If you need the code simplicity of object-oriented hierarchies for your project but love the functional paradigm, you have several choices. If Java is your realm, Scala is the choice for you.

Scala runs on the JVM, bringing all the clean design strictures of functional programming to the Java world by delivering code that fits with the Java class specifications and links with other JAR files. If those other JAR files have side effects and other imperative nasty headaches, so be it. Your code will be clean.


The type mechanism is strongly static and the compiler does all the work to infer types. There's no distinction between primitive types and object types because Scala wants everything to descend from one ur-object call Any. The syntax is much simpler and cleaner than Java; Scala folks call it "low ceremony." You can leave your paragraph-long CamelCase variable names back in Java Land.

Scala offers many of the features expected of functional languages, such as lazy evaluation, tail recursion, and immutable variables, but have been modified to work with the JVM. The basic metatypes or collection variables, like linked lists or hash tables, can be either mutable or immutable. Tail recursion works with simpler examples, but not with elaborate, mutually recursive examples. The ideas are all there, even if the implementation may be limited by the JVM. Then again, it also comes with all the ubiquity of the Java platform and the deep collection of existing Java code written by the open source community. That's not a bad trade-off for many practical problems.

If you must juggle the data in a thousand-processor cluster and have a pile of legacy Java code, Scala is a great solution.

Dart: JavaScript without the JavaScript

Being popular is not all it's cracked up to be. JavaScript may be used in more stacks than ever, but familiarity leads to contempt -- and contempt leads to people looking for replacements. Dart is a new programming language for Web browsers from Google.

Dart isn't much of a departure from the basic idea of JavaScript. It works in the background to animate all the DIVs and Web form objects that we see. The designers simply wanted to clean up the nastier, annoying parts of JavaScript while making it simpler. They couldn't depart too far from the underlying architecture because they wanted to compile Dart down to JavaScript to help speed adoption.


The highlight may be the extra functions that fold in many de facto JavaScript libraries. You don't need JQuery or any of the other common libraries to modify some part of the HTML page. It's all there with a reasonably clean syntax. Also, more sophisticated data types and syntactic shorthand tricks will save a few keystrokes. Google is pushing hard by offering open source development tools for all of the major platforms.

If you are building a dynamic Web app and are tired of JavaScript, Dart offers a clean syntax for creating multiple dancing DIVs filled with data from various Web sources.

Haskell: Functional programming, pure and simple

For more than 20 years, the academics working on functional programming have been actively developing Haskell, a language designed to encapsulate their ideas about the evils of side effects. It is one of the purer expressions of the functional programming ideal, with a careful mechanism for handling I/O channels and other unavoidable side effects. The rest of the code, though, should be perfectly functional.

The community is very active, with more than a dozen variants of Haskell waiting for you to explore. Some are stand-alone, and others are integrated with more mainstream efforts like Java (Jaskell, Frege) or Python (Scotch). Most of the names seem to be references to Scotland, a hotbed of Haskell research, or philosopher/logicians who form the intellectual provenance for many of the ideas expressed in Haskell. If you believe that your data structures will be complex and full of many types, Haskell will help you keep them straight.

POPULAR RESOURCES
VIDEO/WEBCAST
SPONSORED
5 Tips from Intuit for Implementing Static Code Analysis

WHITE PAPER
Critical Considerations When Building Enterprise Node.js Applications
SEE ALL Go
Julia: Bringing speed to Python land

The world of scientific programming is filled with Python lovers who enjoy the simple syntax and the freedom to avoid thinking of gnarly details like pointers and bytes. For all its strengths, however, Python is often maddeningly slow, which can be a problem if you're crunching large data sets as is common in the world of scientific computing. To speed up matters, many scientists turn to writing the most important routines at the core in C, which is much faster. But that saddles them with software written in two languages and is thus much harder to revise, fix, or extend.

Julia is a solution to this complexity. Its creators took the clean syntax adored by Python programmers and tweaked it so that the code can be compiled in the background. That way, you can set up a notebook or an interactive session like with Python, but any code you create will be compiled immediately.

The guts of Julia are fascinating. They provide a powerful type inference engine that can help ensure faster code. If you enjoy metaprogramming, the language is flexible enough to be extended. The most valuable additions, however, may be Julia’s simple mechanisms for distributing parallel algorithms across a cluster. A number of serious libraries already tackle many of the most common numerical algorithms for data analysis.

Original Post - http://www.javaworld.com/article/2842980/scripting-jvm-languages/9-cutting-edge-programming-languages-worth-learning-next.html

I’m a big fan of Sublime Text. As with many Mac programmers, I started on TextMate and then migrated over once Sublime Text 2 was released. When I started, however, there were a lot of things that I didn’t know about ST, so I’ve compiled a list of basic things that are excellent time savers.

Multiple cursors: You can edit multiple lines of code simultaneously very easily by holding down Cmd (ctrl for Windows) and then clicking different lines with your mouse.
Reopening closed tabs: Just as with Chrome, if you accidentally close a file that you’d like to reopen, just press Shift +Cmd + T (or Shift + ctrl + T on Windows). If you keep pressing that key combo, ST will continue opening tabs in the order that you closed them.
Quick file opening: This is perhaps my favorite ST feature. Hold down Cmd + T (or ctrl + T on Windows) to open a textfield that lets you search for files within a project to open. You’ll rarely ever have to use the file tree again.
Jumping to symbols: To quickly jump to specific symbols, hold down Cmd + P (or ctrl + P on Windows) to open up a search field. Type in your symbol and press enter.
Search entire project files: To search the contents of an entire ST project, hold down Shift + Cmd + F (Shift + ctrl + F on Windows).
Jumping between words/lines: This is more of an operating system feature, but I discovered it while using ST. On Macs, if you hold down Alt while using the arrow keys, you jump between words rather than characters. Similarly, if you hold down Cmd while using arrow keys, you jump from the opposite end of a line. Very useful for quickly navigating code without your mouse.
Quickly change settings: Shift + Cmd + P (Shift + ctrl + P on Windows) opens a quick search to allow you to modify Sublime Text preferences.
The following have been additions I’ve seen in the Hacker News comments:

Jumping between word segments: ”If you hold down control, you move by word segment - this is camel-case (and underscore) aware. So, if I am at the front of the word “cakeParty”, I can move to between ‘e’ and ‘P’ by holding control and pressing the right arrow key.” (Thanks hebejebelus)
Move current line up/down: “You can also move the curent line up and down the page using Ctrl + Cmd + Up/Down” (Thanks draftable)
Sublime Package Control: “Useful for installing things like themes, syntax awareness, code linters, etc…” (Thanks po)
Quick word editing: “Cmd + d selects the current word. Subsequent Cmd + d presses will select the following instance of the word for editing. Makes it easy to do things such as renaming a local variable or changing both the opening and closing element of a HTML tag.” (Thanks haasted)
Fine-grained find+replace/modify: “Another one i’ve found useful is CMD+D / CMD+K+D. CMD+D finds the next instance of the current selection and creates another cursor there (and selects it as well). CMD+K+D skips the current selection and finds the next one.” (Thanks toran1302)
Select all instances: You can select all instances using cmd + ctrl + G (Thanks gryghostvisuals)
Go to a specific line: You can jump to a line by using Ctrl + G and typing in the line # (thanks arkinex)
Duplicate current line: “Ctrl/Cmd+Shift+D duplicates line/selected text” (Thanks akinex)

Original Post - http://blog.alainmeier.com/post/27255145114/some-things-beginners-might-not-know-about-sublime-text

Paullo240, a Nairalander, suggest that we build a messenger app in this thread - https://www.nairaland.com/1978581/let-put-hands-together-becoming . I wasn't against it but I told da NL dat if we want to succeed or stand out we need to make ours different and unique. I've come up with ideas such as:

1. Messenger App That Doesn't Use Internet But Relies On Mesh Network.
2. Messenger App With Text and Voice Translation From Pidgin To Hausa To Igbo To Yoruba
3. Messenger App That Allows People To Get An Amount of Money Back When They Click On Certain Ads.

What Are Your Thoughts and Ideas?

paullo240:
I want to develop a chatting app like whatapp with great features and a e-commerce site

Paulo would u be interested in making a messenger app that doesn't use the Internet or data charges? Something like that will sell and make it different than other messenger apps we have in the market.

Africa has its own Mark Zuckerbergs, Andrew Masons, Mark Pincuses, Larry Pages and Sergey Brins. But it lacks its own Yuri Milners, John Doerrs, Vinod Khoslas and Y Combinators.

I recently read Parmy Olson’s interview with Yuri Milner on Forbes’s recent Billionaires issue. It is riveting stuff. Milner, a Russian billionaire venture capitalist, has made a pile of money investing in some of the web’s most brilliant success stories- Facebook, Zynga and Groupon. These companies have rewritten the rules of social networking, connected the world and revolutionized our shopping experiences. They have shaped our lives, influenced popular culture, and brought in stellar returns for their investors- people like Mr. Milner.

But as I read the article, I could not help but ask myself the pertinent yet habitually unanswered question: What about Africa? Why hasn’t a globally-renown, groundbreaking software, social network or mobile application ever emerged from the continent?

From my experiences, I have discovered that Africa equally has its own plethora of techies with earth-shaking ideas, rock-solid business plans and the commercial know-how required to transform a concept into a world-class business concern. There is no shortage of capacity. Africa has some extremely intelligent techpreneurs. Last year, a Kenyan mobile software developer and entrepreneur, John Waibochi, beat several other software developers from the U.S, Canada and India to win the Nokia Innovation Challenge Award. It came with $1 million in prize money. Today, his company, VirtualCity develops pioneering mobile software that’s extremely successful in East African markets. Then there is Mark Shuttleworth, a maverick South African Internet tycoon who founded Thawte, a web security and certificate authority company. Thawte became so successful that it was snapped up by VeriSign (VRSN) for $575 million.

There is also Ory Okolloh, a remarkable Kenyan lady who founded Ushahidi, a hugely popular company that develops open source software for information collection. She recently left Ushahidi to take a job as Google’s Policy Manager for Africa.


Last December in South Africa, I met a remarkable young lady who has developed a voice-based mobile application which helps farmers track the oestrus stages of their cows. It’s amazing. She’s been looking to raise capital to commercialize her invention, and there’s definitely a market for her product, but there are no venture capitalists willing to gamble on her idea.

Africans can create hugely successful tech products that will sweep the world off its feet. There are several entrepreneurs out there waiting to break through, but their ideas might never see the light of day because of a lack of seed finance. This is the reason Africa might never produce a Facebook, Groupon, Zynga or Google: There are no venture capital firms in Africa to fund these ventures. It’s unfortunate. And even if, by any little chance they actually do exist, they possess a flagrant disregard for technology and the very crucial role it is going to play in the future. As a result, they are unwilling to fund this sector and give it the acknowledgement it deserves.

Africa is undergoing a technology renaissance. More than ever before, the population is becoming more technologically-inclined, more web-dependent. With the right financing, our entrepreneurs can put Africa on the global map of technological innovation.

But until its financiers and the self-proclaimed ‘venture capitalists’ are easily accessible and listen to these entrepreneurs, Africa may never have its own answers to such internationally famed corporations like Google, Facebook, Zynga and the rest of them. Africa needs several Y Combinator-type firms who will believe in and support the dreams of entrepreneurs and get those big ideas out of the boxes and into the pages of history. Africa’s techies are equally as smart, gifted and visionary and if supported can transform big ideas into money-making, world-class companies that’ll change the world.

So, will the venture capitalists please stand up?

Original Post - http://www.forbes.com/sites/mfonobongnsehe/2011/04/07/why-africa-may-never-produce-a-facebook-groupon-zynga-or-google/

I've been programming for over 30 years from machines that seem puny today (Z80 and 6502 based) to the latest kit using languages that range from BASIC, assembly language, C, C++ through Tcl, Perl, Lisp, ML, occam to arc, Ruby, Go and more.

The following is a list of things I've learnt.

0. Programming is a craft not science or engineering

Programming is much closer to a craft than a science or engineering discipline. It's a combination of skill and experience expressed through tools. The craftsman chooses specific tools (and sometimes makes their own) and learns to use them to create.

To my mind that's a craft. I think the best programmers are closer to watchmakers than bridge builders or physicists. Sure, it looks like it's science or engineering because of the application of logic and mathematics, but at its core it's taking tools in your hands (almost) and crafting something.

Given that it's a craft then it's not hard to see that experience matters, tools matter, intuition matters.

1. Honesty is the best policy

When writing code it's sometimes tempting to try stuff to see what works and get a program working without truly understanding what's happening. The classic example of this is an API call you decide to insert because, magically, it makes a bug go away; or a printf that's inserted that causes a program to stop crashing.

Both are examples of personal dishonesty. You have to ask yourself: "Do I understand why my program is doing X?". If you do not you'll run into trouble later on. It's the programmer's responsibility to know what's going on, because the computer will do precisely what it's told not what you wish it would do.

Honesty requires rigor. You have to be rigorous about ensuring that you know what your program does and why.

2. Simplify, simplify, simplify

Tony Hoare said: "There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult."

Simplify, refactor, delete.

I'd rephrase Hoare's maxim as "Inside every large, complex program is a small, elegant program that does the same thing, correctly".

Related to this is the 'small pieces loosely joined' philosophy. It's better to structure a program in small parts that communicate than to create some gigantic monolith. This is partly what has made UNIX successful.

3. Debuggers are sometimes a crutch, profilers are not

I almost never use a debugger. I make sure my programs produce log output and I make sure to know what my programs do. Most times I can figure out what's wrong with my code from the log file without recourse to a debugger.

The reason I don't use a debugger much is I think it leads to lazy thinking. Many people when faced with a bug reach for the debugger and dive into setting breakpoints and examining memory or variable values. It's easy to become enamored with such a powerful tool, but a little bit of thinking tends to go a long way. And if your program is so complex that you need a debugger you might need to go back to #2.

(Aside: having said all that, one of the programmers I most respect, John Ousterhout, seemed to spend all day in the Windows debugger).

On the other hand, profilers are essential if you need to understand performance. You'll never cease to be amazed what a profiler will tell you.

4. Code duplication will bite you

Don't Repeat Yourself. Do everything just once in your code.

This is related to #2, but is a special case. Even a simple piece of code that's duplicated will lead to trouble later when you 'fix' one version and forget about the other one.

5. Be promiscuous with languages

Some people get obsessed with a specific language and have to do everything in it. This is a mistake. There is not single greatest language for all tasks.

The key thing is to know which language in your toolbox you'll use for which problem. And it's best to have lots of tools. Try out different languages, build things in them.

For example, perhaps you'll not use Python or ML very much but you'll have played with list comprehensions and seen their power. Or you'll dabble in Go and will have seen how it handles concurrency. Or you'll have used Perl and seen the power of really flexible string handling. Or you'll have used PHP to quickly build a dynamic web page.

I hate language wars. They're basically for losers because you're arguing about the wrong thing. For example, in my hands PHP is a disaster, in the hands of others people make it sing. Similar things can be said about C++.

6. It's easier to grow software than build it

This is related to #2. Start small and grow out. If you are attacking a problem then it's easier to grow from a small part of the problem that you've tackled (perhaps having stubbed out or simulated missing parts) than to design a massive architecture up front.

When you create a massive architecture from the start you (a) get it wrong and (b) have created a Byzantine maze that you'll find hard to change. If, on the other hand, you work from small pieces that communicate with each other, refactoring will be easier when you realize you got it wrong from the start.

The root of this is that you never know what the truly correct architecture will look like. That's because it's very rare to know what the external stimuli of your program will be like. You may think that you know, say, the pattern of arriving TCP traffic that your mail server will handle, or the number of recipients, or you may not have heard of spam. Something will come along from outside to mess up your assumptions and if your assumptions have been cast into a large, interlocked, complex program you are in serious trouble.

7. Learn the layers

I think that having an understanding of what's happening in a program from the CPU up to the language you are using is important. It's important to understand the layers (be it in C understanding the code it's compiled to, or in Java understanding the JVM and how it operates).

It helps enormously when dealing with performance problems and also with debugging. On one memorable occasion I recall a customer sending my company a screenshot of a Windows 2000 crash that showed the state of a small bit of memory and the registers. Knowing the version of the program he had we were able to identify a null pointer problem and its root cause just from that report.

8. I'm not young enough to know everything

I've still got plenty to learn. There are languages I've barely touched and would like to (Erlang, Clojure). There are languages I dabble in but don't know well (JavaScript) and there are ideas that I barely understand (monads).

PS It's been pointed out that I haven't mentioned testing. I should have added that I do think that test suites are important for any code that's likely to be around for a while. Perhaps when I've been programming for another 30 years I'll have an answer to the question "Do unit tests improve software?". I've written code with and without extensive unit tests and I still don't quite to know the answer, although I lean towards unit tests make a difference.

Original Post - http://blog.jgc.org/2012/07/some-things-ive-learnt-about.html

If you can, imagine a time before the invention of the Internet. Websites didn’t exist, and books, printed on paper and tightly bound, were your primary source of information. It took a considerable amount of effort—and reading—to track down the exact piece of information you were after.

Today you can open a web browser, jump over to your search engine of choice, and search away. Any bit of imaginable information rests at your fingertips. And chances are someone somewhere has built a website with your exact search in mind.

Within this book I’m going to show you how to build your own websites using the two most dominant computer languages—HTML and CSS.

Before we begin our journey to learn how to build websites with HTML and CSS, it is important to understand the differences between the two languages, the syntax of each language, and some common terminology.

Continue Here ~> http://learn.shayhowe.com/html-css/building-your-first-web-page/

African technology is in an exciting and vibrant phase with many talented developers and an unprecedented access to global markets.

However, this is not a situation unique to Africa. App development has exploded all across the world. What this means for African developers and entrepreneurs is that they are not only competing for the same global market but also facing stiffer competition for their local markets.

To be able to compete in this new world – to be able to survive – African developers and entrepreneurs will need to understand and adapt to this reality.

'African Apps in a Global Marketplace' is a useful read for African app developers or anyone interested in the state of the African app industry. It presents the reader with the points to consider in taking their app from a simple and fun idea into a product that can be successful globally. From conceptualisation to design, funding and marketing. Most importantly, it informs on how African apps can stand out in the crowded global marketplace.

Link - http://issuu.com/weareasilia/docs/african_apps_in_a_global_marketplace

okete:
I need someone very good in programming to help me in a program that can give pure sine wave

You didnt say in what specific programming language, so Ima give you options:

In Java:
package example.fixedfreqsine;

import java.nio.ByteBuffer;
import javax.sound.sampled.*;


public class FixedFreqSine {

//This is just an example - you would want to handle LineUnavailable properly...
public static void main(String[] args) throws InterruptedException, LineUnavailableException
{
final int SAMPLING_RATE = 44100; // Audio sampling rate
final int SAMPLE_SIZE = 2; // Audio sample size in bytes

SourceDataLine line;
double fFreq = 440; // Frequency of sine wave in hz

//Position through the sine wave as a percentage (i.e. 0 to 1 is 0 to 2*PI)
double fCyclePosition = 0;

//Open up audio output, using 44100hz sampling rate, 16 bit samples, mono, and big
// endian byte ordering
AudioFormat format = new AudioFormat(SAMPLING_RATE, 16, 1, true, true);
DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);

if (!AudioSystem.isLineSupported(info)){
System.out.println("Line matching " + info + " is not supported.";
throw new LineUnavailableException();
}

line = (SourceDataLine)AudioSystem.getLine(info);
line.open(format);
line.start();

// Make our buffer size match audio system's buffer
ByteBuffer cBuf = ByteBuffer.allocate(line.getBufferSize());

int ctSamplesTotal = SAMPLING_RATE*5; // Output for roughly 5 seconds


//On each pass main loop fills the available free space in the audio buffer
//Main loop creates audio samples for sine wave, runs until we tell the thread to exit
//Each sample is spaced 1/SAMPLING_RATE apart in time
while (ctSamplesTotal>0) {
double fCycleInc = fFreq/SAMPLING_RATE; // Fraction of cycle between samples

cBuf.clear(); // Discard samples from previous pass

// Figure out how many samples we can add
int ctSamplesThisPass = line.available()/SAMPLE_SIZE;
for (int i=0; i < ctSamplesThisPass; i++) {
cBuf.putShort((short)(Short.MAX_VALUE * Math.sin(2*Math.PI * fCyclePosition)));

fCyclePosition += fCycleInc;
if (fCyclePosition > 1)
fCyclePosition -= 1;
}

//Write sine samples to the line buffer. If the audio buffer is full, this will
// block until there is room (we never write more samples than buffer will hold)
line.write(cBuf.array(), 0, cBuf.position());
ctSamplesTotal -= ctSamplesThisPass; // Update total number of samples written

//Wait until the buffer is at least half empty before we add more
while (line.getBufferSize()/2 < line.available())
Thread.sleep(1);
}


//Done playing the whole waveform, now wait until the queued samples finish
//playing, then clean up and exit
line.drain();
line.close();
}
}

paullo240:
I want to develop a chatting app like whatapp with great features and a e-commerce site

There's nothing wrong in making a chat app or e-commerce site but there are so many out here. Like y would people want 2 use da 1 dat we make? What will make ours different?

This might be an old link but here is 100 - 500 More at this site ~> https://github.com/vhf/free-programming-books/blob/master/free-programming-books.md#professional-development

Coding in Python is not hard, in fact – it has been acclaimed as the easiest programming language to learn for a long time. It is a good starting point if you’re looking to get into web development, even game development – as there are so many resources for building games with Python. It’s one of the ways of learning the language quickly.

Many programmers have used Python as the beginning of their journey, to later pick up languages like PHP and Ruby. It’s also one of the hottest web programming languages in 2014, and highly recommended to learn. But, how to learn Python? Where to go to begin learning?

I’m here to solve that problem for you, as I’ve myself relied on many of these resources to learn programming, and begin development. Just a friendly tip and word of advice, the best way to learn is by doing – and these books, resources are here only to guide you in the right direction.

It can be EXTREMELY frustrating to begin learning, but once you get the basics down – it comes to you naturally, and you’re building things without thinking about it.

Python for Beginners

Python for Beginners

If you’ve been meaning to get your Python development journey under way for a while now, this course might be a really good start. The Python for Beginners course as instructed by Alex Bowers is one of the most comprehensive, yet easy to digest Python tutorials on the web right now. Yes, it comes at a price tag, but do you want to learn alone, or alongside 30,000 other students?

The advantage of signing up for this course is that you’re granted access to a members only forum, where Alex (the instructor) himself is residing, and will gladly help to tackle your Python problems, whenever possible. I mean, it goes over everything that any of the other resources in this list would, with the exception that you get a community feel for having invested a little bit of dough into it.

You can use the coupon code: CODECONDO – it will give you a solid 75% discount, though it is going to be active only up until 30/09/2014 – so hurry up, you can always purchase the course and then work with it later, don’t waste your money by missing this deal!

Learn Python the Hard Way

Learn Python the Hard Way

The absolute easiest way of learning Python is by completing this book. You’ll be amazed at how easy it is to pickup the basics, and you get that sense of real learning process, acquiring new knowledge as you move forward. I also learned that it is very encouraging to try and create your own programs.

Those programs might be small, but they’ll definitely help you better understand the language and how the syntax works. It’s highly popular, and so if you ever get stuck, it’s more than likely that there are several answers available on sites like StackExchange, just do a Google search when you need a solution or help.

You’ll learn how to:

Setup Python Programming Environment on All Platforms
Write Python Programs
Understand Python Syntax and Documentation
Think Like a Programmer
a lot more!
The HTML online version is completely free, and it’s also what most people use – I do encourage you to donate / purchase the full book, as the author has put a lot of effort into making it happen, and the premium version also includes videos – if you find learning from videos a lot easier.

The Python Challenge

The Python Challenge

It might be a little tricky to get this one going, if you’ve never in your life programmed before, but it goes together well with the above book, and you should definitely give it a go. There are 33 levels (puzzles), which can be solved by using your Python programming skills.

Millions of people have attempted to solve this, and even if you’re unable to complete all of the levels, you’ll have learned quite a few new things – especially in the field of critical and sharp thinking. Your brain is going to overheat, but that’s programming!

Learn Python Programming @ Codecademy

Learn Python Programming I Codecademy Online Tutorials

You’ll find that many ‘elite’ programmers will tell this interactive platform off, but that’s not the point. What we want is to see / test how the basic syntax of a programming language works, and what can be done when its combined with functions, other than the usual ‘Hello World!’ we’re printing.

In this Codecademy course you will learn how to work with files, how to use loops and how they work, what are functions and what they’re good for. It’s all very basic, and very beginner friendly. There is community forums available for those who need help, but usually everything can be understood from within the dashboard you’re working with.

You won’t need to install any tools, and the only thing you might need is a Notepad++ editor, to rewrite the code on your own computer – for gaining better understanding of it. It’s what I do, and I recommend it to everyone who wants to learn programming, be it Python or any other language.

Intro to Computer Science @ Udacity

Advance Your Career Through Project-Based Online Classes - Udacity

Udacity offers a great course at free of charge, for introducing yourself to the Python programming language and learning more about search engines, and how to build your own little web crawler. It certainly is a fun course to take part of, and it offers extensive guides and community support to help you along the way.


You can enroll as premium student to receive guidance from the instructors, and gain a certificate by the end of the course – or you can start the free courseware to get going right away, unfortunately – the premium full course is at limited capacity, and so you have to signup for a waiting list.

In total, there are 11 classes, all of which are thoroughly explained and documented. Go to the official page to learn more and find more answers to the questions you might have.

Google’s Python Class

Google's Python Class - Educational Materials — Google Developers

Google itself is powered by a lot of Python code, and so it only makes sense that they support the community and want to help others learn the language. This is one of my favorite guides / classes I’ve ever viewed, it’s really detailed and the videos are very beginner friendly and also entertaining to watch.


Just watch a couple of minutes of the first lecture above, to get a better sense of whether you like the instructor or not, and then perhaps start learning! The official Python Class page has all of the links to exercises and examples.

A Byte of Python

A Byte of Python

Very similar to LPTHW, but offers a slightly more in-depth introduction on how to get your perfect setup up and running, and how to take the first steps so you don’t overwhelm yourself. It has been recognized as one of the best beginner guides for those who want to learn Python, definitely check it out and see the first few chapters to figure out whether you like the style of writing.

Think Python

Think Python_ How to Think Like a Computer Scientist

Think Python is an introduction to Python programming for beginners. It starts with basic concepts of programming, and is carefully designed to define all terms when they are first used and to develop each new concept in a logical progression. Larger pieces, like recursion and object-oriented programming are divided into a sequence of smaller steps and introduced over the course of several chapters.

You can find a lot of the example code by following this link, it’s one of the most professional books and have a strict “teaching you computer science” policy. It costs nearly $40 to purchase, but you can download the PDF and HTML versions for free, I’d definitely take advantage of this – if I was to learn Python from the beginning.

Python at Learnstreet

Python at Learnstreet

You’d think that a site offering programming courses would know how to add a HTML title for their pages, lol. In all seriousness though, Learnstreet offers a great interactive programming course for learning Python, its beginner friendly as everything in this post is – and if you ever run into problems, its best to Google them.

What I like about Learnstreet is the amount of hints / explanation you get with each of the exercises, right within the same dashboard that you write your code in.

The New Boston

List of Videos for Python

If you’re more like someone who likes to learn from video tutorials, I’m not sure there is anything as comprehensive as The New Boston video tutorial series for learning Python, and many other programming languages as can be seen on their YouTube channel.

The only downside is that there is no real material for you to read or download, and it all comes in video format. I’m the type of programmer who cant withstand having to watch videos all the time, but that might clash with my opinion with the Google’s Python class – which was pretty sweet.

Python @ Coursera

Learn to Program_ The Fundamentals I Coursera

This course is intended for people who have never programmed before. A knowledge of grade school mathematics is necessary: you need to be comfortable with simple mathematical equations, including operator precedence. You should also be comfortable working with simple functions, such as f(x) = x + 5.

It should be completed with ten weeks, spending around ten hours of work on the tasks each week. If you’re able to find the time to do it, and not overwhelm yourself – I do recommend signing up and completing this course, it will only strengthen your knowledge, and it can be combined with any of the above mentioned resources for better understanding.

Python for you and me

Welcome to Python for you and me — Python for you and me 0.3.alpha1 documentation

Kushal Das has written a nice online book for students, beginners and anyone else curious enough to learn more about Python. I would say that this book is similar to the one we looked at the beginning of the article (Learn Python the Hard Way), with the only exception that the author has different experience, and writing style. Everything else, you’ll be learning step by step.

By the end of the book, you’ll be looking at structuring projects, and there is also a small introduction to the Flask framework (which was been mentioned in the minimal frameworks post), on top of that – there is a separate section for learning testing with Python.

LearnPython

Welcome Learn Python Free Interactive Python Tutorial

If you’re an interactive learner (or simply prefer to learn that way), then Learn Python is a great alternative (to Codecademy) to try out. There is a section of basic tutorials, and also some more advanced ones that will give you deeper understanding of the language. Worth noting: there are tutorials for other – Java, C, JavaScript, PHP, Shell, C# – languages as well, so definitely worth checking out.

Quiz & Learn Python

Quiz Learn Python — Mobile IceCube

It’s very possible that you lead a busy life, and so don’t have a lot of time to be spending learning the basics of Python, so here’s a great mobile application that will test your skills through quizzes and puzzles. You can finally carry your programming practice with you, and even if you’re learning only a little bit – at least you’re keeping your memory fresh and engaged with all the different programming patterns.

Invent Your Own Computer Games with Python

inventwithpython.com

In this book, you’re going to be building about twenty different scripts (or should we say, games) and that will put you through a great learning curve for learning how to build games with Python. It is worth knowing that massive games such as EVE Online have been built using Python. (more specifically: StacklessPython)

I’m not a Python game developer, but I’ve seen some great games have being been built with this language, and if you’ve been meaning to combine your learning experience with game development, this might be a great book to try out. (to be fair, even those who’re not interested in gaming, should give this book a try)


Dive Into Python 3

Python like any other programming language is constantly growing, and finally we’re seeing a decrease in Python 2 users, an increase in the amount of developers using Python 3; and there have even been talks of Python 4 already, so perhaps it’s not such a bad idea to begin your switch now. You’ll enjoy what this book has to offer, as it gives you a fresh perspective of what Python 3 is, and how to use it to build even more amazing software.

You can learn more about some of the changes in Python 3 in this slideshow.

Where to Learn Python?

It turns out that I’ve tried most of these courses myself, I was actually hoping there would be more resources and links to add to the list, but we’ve just taken a look at all of the major ones and there is so much stuff and new things you’re going to be learning about.

What is your experience with programming, and what are you looking to do with your newly found skills? I think that anyone who wants to build their expertise, should first acknowledge what they want to build and then work on that project until it gets done. The beauty of doing that is that you’ll learn specific things, and recreating similar projects will be much easier.

Interactive platforms are cool, but they’re not yet ready to replace books or courses provided and narrated by professionals. I wish you the best of luck with learning Python, and please – if you’ve got any questions to ask, do so in the comment box.

Original Link - http://codecondo.com/10-ways-to-learn-python/

Wanna be a programmer? That shouldn’t be too hard. You can sign-up for an iterative online tutorial at a site like Codecademy or Treehouse. You can check yourself into a “coding bootcamp” for a face-to-face crash course in the ways of programming. Or you could do the old fashioned thing: buy a book or take a class at your local community college.

But if want to be a serious programmer, that’s another matter. You’ll need hundreds of hours of practice—and countless mistakes—to learn the trade. It’s often more of an art than a skill—where the best way of doing something isn’t the most obvious way. You can’t really learn to craft code that’s both clear and efficient without some serious trial and error, not to mention an awful lot of feedback on what you’re doing right and what you’re doing wrong.

That’s where a site called Exercism.io is trying to help. Exercism is updated every day with programming exercises in a variety of different languages. First, you download these exercises using a special software client, and once you’ve completed one, you upload it back to the site, where other coders from around the world will give you feedback. Then you can take what you’ve learned and try the exercise again.

It’s a simple idea. But it could help the legions of people out there trying to learn to code well enough to land a job in this fast-growing field. In recent years, we’ve seen the arrival of so many tools that help turn anyone into a programmer, and this is one step towards widespread “code literacy.”

Software developer Katrina Owen created Exercism.io while she was teaching programming at Jumpstart Labs in Denver, Colorado. Every day, she provided “warm-up” problems for the students. The only problem was: the students rarely finished them. “If they got stuck, they wouldn’t ask their mentor for anything,” she says. “And towards the end of their term I was seeing them making very basic mistakes that these warm-ups should have taught them.”
To solve the problem, she created a site last year that presents the practice problems and prevents students from being able to move on to the next ones without submitting a solution to the previous problem. The idea was to have students not only complete the exercises, but get feedback. Soon, students were working on the problems on their lunch breaks and on evening and weekends. They were obsessed with these little problems.

But it didn’t stop there. Because Exercism.io was available on the open web, her students began telling their friends. Within a month, several hundred people were already using the site. And because the site is open source and hosted on the code collaboration service GitHub, anyone can submit new exercises to the site. Exercism.io now has over 6,000 users who have submitted code or comments, and hundreds of volunteers submit new exercises or translate existing ones into new programming languages.

Owen, who now works for the Santa Monica, California-based music collaboration startup called Splice says she has no plans to turn the site into a business. But she would like to raise money to pay people to improve it. For example, she admits that the site is a bit lack in the usability department. “It’s hard to tell what it is just by looking at it,” she says. “It’s remarkable to me that people have figured out how to use it.”

Original Link - http://www.wired.com/2014/09/exercism/

As the old Faces song "Ooh La La" goes, I wish that I knew what I know now when I was younger. Back then, I simply loved to code and could have cared less about my "career" or about playing well with others. I could have saved myself a ton of trouble if I'd just followed a few simple practices.

FEATURED RESOURCE

Presented by Citrix Systems
10 essential elements for a secure enterprise mobility strategy
Best practices for protecting sensitive business information while making people productive from
LEARN MORE
1. Take names. I was really focused on computers early in my career and considered people to be minor annoyances who kept me from being one with my beloved machine. OK, I'm exaggerating a little. Despite meeting many industry luminaries and people that would have been worthwhile to befriend, I didn't keep any business cards. I didn't bother to remember their names and never checked in on them. I only went to user groups (there wasn't meetup.com when I started and it wasn't a big thing for a while after) when I needed a job.

I realize the concept of needing a job seems a little quaint to some of you younger developers. But take it from me -- there've been times when merely saying you're a developer and knowing basic syntax and how to search (there was no Google when I started) was not enough to find immediate employment. There was a time when developers actually called headhunters versus being spammed by them endlessly. This will happen again, eventually.

More important, a lot of developers who were more skilled than I am have had far less interesting careers and less success because they never put themselves out there. They never met the right people at the right moments. Hey, timing and luck are great, but you also make your own opportunities. The first nine times you go to a large gathering and no one speaks to you and you're left with all the perks of being a wallflower are practice for the 10th time when you meet someone interesting.

Also, take note of your peers. If you're an early 20-something, chances are you have no real power or influence, and neither do your peers. In five to 10 years, that will all be different and the person who you ignored because they were boring and couldn't help you will be the person who could have won you an important opportunity.

2. Problem solving. Luckily, this came pretty naturally to me after a while, but early on it was a struggle. The trick is tonever fall in love with any one theory of the problem. Pick three theories and go about proving them wrong rather than trying to prove yourself right. Also, gravitate toward alternative theories. If something says there is a port conflict and you can't find any port conflict, then maybe you're connecting to the wrong network device or an unassigned IP address, and the error is bogus.


Problem solving is essentially the same thing you learned in abstract in seventh or eighth grade or whenever you learned simple algebra. Remove all of the variables that you can, then solve for x.

3. Pick your language or other technical specialties based on the market and your career goals. Sure, you want to do what you love, but really is Scala (insert other language name here) your real love in life, to the point where you are willing to tie your success or failure to it? A better reason would be that it is a smaller talent pool and you might be able to make more money doing it and you know that the finance and scientific community near you is big enough and using it avidly. (It also might be you want to work for Typesafe.)

Either way, pick rationally rather than based on some weird zeal for a syntax. Hadoop is wicked cool, that's a fact. However, analysts are predicting the market will grow several times in the next couple of years, and there is a huge uptake. Companies are building out major infrastructure in a way I haven't seen since the '90s. I think PaaS is awesome, but I do not see tons of business opportunity for developers here. Publicly show passion and enthusiasm, but privately make this a cold, hard calculus and business decision. Your favorite technology will be dead probably before the end of your career anyhow.

4. There is relatively little real innovation in the software side of the industry compared to popular perception. Most of us who have done this for more than five years have already watched all the vendors rename everything and sell it as new at least once. Anyone working for more than 10 years has seen it a few times. When you go into a meeting with a bunch of old people, realize that they roll their eyes at many of the things you think are new. There are some innovations, but those are usually combinations of previous technologies. While Hadoop may be hot, HDFS is a distributed filesystem and distributed filesystems have existed for decades.

RECENT JAVA HOW-TOs
on target
Stability patterns applied in a RESTful architecture
ChoiceFormat: Numeric range formatting
Google Go
Fast guide to Google Go programming
5. Think in terms of a career, not a series of jobs. When I started I job-hopped for relatively dumb reasons: I didn't like that I was put in a cubicle, I could get an extra $5 per hour, and so on. This would come back to haunt me during the dot-bomb. At the same time, I usually failed to pick jobs for the best reason: What will help me progress in my career? Sometimes that means taking a job for less money but more responsibility or better opportunities. I probably still have put in my time at big companies -- then quit working for them sooner. It's relatively hard to make an impact from the inside of IT in a big company and opportunities are frequently limited.

6. Work more than 40 hours per week. I don't mean you should work in a sweatshop or run yourself to death, but make a personal investment in your career. If the only time you learn something is on your boss's dime, then prepare to have your options limited -- your boss isn't going to train you to make sure you have options.

7. Programming is not hard unless you make it hard. I disagree with Joseph Gentle. People are still messing up software development in the same dumb ways since software separated from hardware. Programming simply requires reading, concentration, and logic. Luckily, plenty of books, courses, and patterns can tell you how to do all of that (see No. 6). Coordination with other people on any scale? That's hard.

8. For Zod's sake, learn to communicate. If you are unable to write properly in English (or the appropriate language for your community), take a writing course. If you are unable to give a talk, get over your stage fright, take a course, practice in front of a mirror, and/or attend some meetups and learn. This is probably as important as writing code.

Now it's your turn. If you're more than five years in, what do you wish you'd known at the start? If you're less than five years in, what advice have you found helpful?

Link ~> http://www.javaworld.com/article/2597522/learn-java/what-i-wish-id-known-starting-out-as-a-programmer.html

You've always wanted to learn how to build software yourself—or just whip up an occasional script—but never knew where to start. Luckily, the web is full of free resources that can turn you into a programmer in no time.

Since the invention of the internet, programmers have been using it to discuss software development techniques, publish tutorials, and share code samples for others to learn from and use online. If you're curious about how to become a programmer, you can get off to a running start using tons of great free web-based tutorials and resources.3

First Things First: Don't Get Hung Up on Choosing a Language

Programmer 101: Teach Yourself How to Code
A common pitfall for beginners is getting stuck figuring out which programming language is best to learn first. There are a lot of opinions out there, but there's no one "best" language. Here's the thing: In the end, language doesn't matter THAT much. Understanding data and control structures and design patterns does matter very much. Every language—even a simple scripting language—will have elements that you'll use in other languages as well and will help you learn. In classes I took to get my degree in Computer Science, I programmed in Pascal, Assembly, and C—languages I never actually got paid to program in professionally. I taught myself every language I've used in my career, reusing concepts I already knew, and referring to documentation and books to learn its syntax. So, don't get hung up on what language to learn first. Pick the kind of development you want to do, and just get started using one that works.

There are several different kinds of software development you can do for various platforms, from the web to your desktop to your smartphone to a command line. In this article, we'll outline some of our favorite starter tutorials and resources for teaching yourself how to program for each major platform. We're going to assume you're a savvy user, but a newb when it comes to wrangling code snippets, so we'll keep things at the beginner level. Even just following through a beginner programming tutorial, you'll be happy to see how far you can get.

Desktop Scripting

The easiest way to try your hand at programming for your Windows or Mac desktop is to start with a scripting or macro program like AutoHotkey (for Windows) or Automator (for Mac). Right now hardcore coders throughout the Lifehacker readership are yelling at their monitors, saying that AHK or AppleScript are not "real" programming. That may be true—technically these types of tools just do high-level scripting. But for those new to programming who just want to get their feet wet, automating actions on their desktop, these free tools are a fantastic way to start—and you'd be surprised at how much you can do with them.

Programmer 101: Teach Yourself How to Code
EXPAND
45
For example, Adam developed the standalone Windows application we all know and love, Texter, using AutoHotkey, so this scripting language is capable of far more than just small-scale automation projects. To get started with AutoHotkey, check out Adam's tutorial on how to turn any action into a keyboard shortcut using AutoHotkey. (Then, check out the source code for Texter to see the innards of a full-fledged AHK-based Windows application.)


Lifehacker Code: Texter (Windows)
Windows only: Text substitution app Texter saves you countless keystrokes by replacing…
Read more
Web Development

Instead of being bound to specific programming languages and the look and feel of a particular operating system, you can put your killer application in the browser and run it in the cloud, as a webapp. Welcome to the wonderful world of web development.

HTML and CSS: The first thing you need to know to build any web site is HTML (the page markup that makes up web pages) and CSS (the style information that makes that markup look pretty). HTML and CSS are not true programming languages—they're just page structure and style information. However, you should be able to author simple HTML and CSS by hand before you begin building web applications, because a web page is the frontend to every webapp. This HTML tutorial is a good place to start.

JavaScript: Now that you can lay out a static web page with HTML and CSS, things get fun—because it's time to learn JavaScript. JavaScript is the programming language of the web browser, the magic that makes dynamic in-page effects go. JavaScript is also the stuff of bookmarklets, Greasemonkey user scripts, and Ajax, so it's the key to making all sorts of web goodies. Start learning JavaScript here.

Programmer 101: Teach Yourself How to Code
6
Server-side scripting: Once you're good at making things happen inside a web page, you're going to need to put some dynamic server action behind it—and for that, you'll need to move into a server-side scripting language, like PHP, Python, Perl, or Ruby. For example, to make a web-based contact form that sends an email somewhere based on what a user entered, a server-side script is required. Scripting languages like PHP can talk to a database on your web server as well, so if you want to make a site where users can log in and store information, that's the way to go. Excellent web development site Webmonkey is full of tutorials for various web programming languages. See their PHP Tutorial for Beginners. When you're ready, check out how to use PHP to talk to a database in WebMonkey's PHP and MySQL tutorial. PHP's online documentation and function reference is the best on the web. Each entry (like this one on the strlen function) includes user comments at the bottom which are often as helpful as the documentation itself. (I happen to be partial to PHP, but there are plenty of other server-side scripting languages you might decide to go with instead.)

Programmer 101: Teach Yourself How to Code
7
Web frameworks: Over the years, web developers have had to solve and resolve the same problems and rewrite similar code to build dynamic web sites. To avoid making everyone reinvent the wheel for every new web development project, some programmers have come up with development frameworks that do some repetitive work for you. The popular Ruby on Rails framework, for example, takes the Ruby programming language and offers a web-specific structure for getting common web application tasks done. In fact, Adam used Rails to build his first serious (and impressive!) web application, MixTape.me. Here's his take on how to build a web site from scratch with no experience. Other popular web development frameworks include CakePHP (for PHP programmers), Django (for Python programmers), and jQuery (for JavaScript).


How to Build a Web Application from Scratch with No Experience
I took one (bad) computer science class in college, and I'm not a web developer. So in early…
Read more
Web APIs: An API (Application programming interface) is a programmatic way for different pieces of software to talk to one another. For example, if you want to put a dynamic map on your web site, you want to use a Google Map instead of building your own custom map. The Google Maps API makes it easy to programmatically include a map in a page with JavaScript. Almost every modern web service you know and love has an API that lets you include data and widgets from it in your application, like Twitter, Facebook, Google Docs, Google Maps, and the list goes on. Integrating other webapps into your web application via API's is the final frontier of rich web development. Every good, major web service API offers thorough documentation and some sort of quick start guide to try it out (here's Twitter's, for example). Go crazy.

Command Line Scripting

If you want to write a program that takes textual or file input and outputs something useful, the command line is the right place to do it. While the command line isn't as sexy or good-looking as a webapp or desktop app, for rapid development of quick scripts that automate processes, you can't beat it.

Several scripting languages that work on a Linux-based web server also work at the command line, like Perl, Python, and PHP—so learning one of those baddies makes you conversant in two contexts. My path never took me too far down the Perl road, but I taught myself Python using the excellent and free online book, Dive into Python.8

Programmer 101: Teach Yourself How to Code
EXPAND
910
If becoming a Unix ninja is one of your programmer goals, you absolutely must get good at shell scripting with bash. Bash is the command line scripting language of a *nix environment, and it can do everything from help you set up automated backups of your database and files to building out a full-fledged application with user interaction. Without any experience writing bash scripts beyond a dozen lines, I wound up developing a full-on personal to-do list manager in bash, Todo.txt CLI.

Add-ons

Nowadays, modern webapps and browsers are extensible with with bits of software that bolt onto them and add features. Add-on development is gaining in popularity as more developers look at existing software, like Firefox or WordPress, and think "But if only it could do THIS..."

You can do a whole lot in any web browser with just a mastery of HTML, JavaScript, and CSS. Bookmarklets, Greasemonkey user scripts, and Stylish user styles are created with the same bits of code that make regular web pages, so they're worth learning even if you just want to tweak an existing site with a small snippet of code.

More advanced browser add-ons, like Firefox extensions, let you do more. Developing Firefox extensions, for example, requires that you're conversant in JavaScript and XML (markup that's similar to HTML, but way more strict in format). Back in 2007 I ran down how to build a Firefox extension, a skill I picked up after I stumbled upon a free tutorial.


How to build a Firefox extension
Ever since we started releasing home-brewed Firefox extensions here at Lifehacker, several readers…
Read more
Many free and well-loved web applications offer an extension framework as well, like WordPress and MediaWiki. Both of those apps are written in PHP, so comfort with PHP is a prerequisite for getting started. Here's how to write a plug-in for WordPress. Developers who want to ride the cutting edge of Google Wave can get started writing gadgets and bots in HTML, JavaScript, Java, and Python. I wrote my first Wave bot following this quick start tutorial in one afternoon.

Web Development for the Desktop

The best part about getting started programming in one context is when you can take those skills and apply them elsewhere. Learning web development first is a great way to start because now there are ways to put those skills to work on desktop applications, too. For example, Adobe AIR is a cross-platform run-time environment that lets you build your app once and release it to run on the desktop for every operating system AIR runs on. AIR apps are written in HTML, Flash, or Flex, so it lets you apply your web development skills in a desktop context. AIR is a great option for deploying desktop apps like one of our top 10 apps worth installing Adobe AIR for.


Top 10 Apps Worth Installing Adobe AIR For
Adobe AIR, a downloadable platform for running web-friendly apps on any operating system, is still…
Read more
Mobile App Development

Mobile applications like the ones you run on your iPhone or Android smartphone are all the rage right now, so you may have dreams of striking it rich in the iTunes App Store with the next killer app. However, for the new coder, diving headfirst into mobile development can be a rough learning curve, since it requires comfort with advanced programming languages like Java and Objective C. However, it's worth checking out what iPhone and Android development looks like. Check out this simple iPhone application development example to get a taste of what iPhone developers do. Android apps are written in Java, and here's a friendly video tutorial of what building a "Hello Android" application workflow looks like.

Patience, Elbow Grease, Trial and Error

Good coders are a special breed of persistent problem-solvers who are addicted to the small victories that come along a long path of trial and error. Learning how to program is very rewarding, but it can also be a frustrating and solitary experience. If you can, get a buddy to work with you along the way. Getting really good at programming, like anything else, is a matter of sticking with it, trying things out, and getting experience as you go.

This article is just one self-taught programmer's top-of-mind recommendations for beginners. Experienced programmers: What did I miss? No matter your skill level, add your thoughts and recommendations for beginners to the comments

Original Post - http://lifehacker.com/5401954/programmer-101-teach-yourself-how-to-code