Get Started for FREE
Sign up with Facebook Sign up with X
I don't have a Facebook or a X account
 Your new post is loading...
Your new post is loading...
Scoop.it!
No comment yet.
Sign up to comment
Scoop.it!
Yahoo! home page engineer Nicholas Zakas, author of Professional JavaScript for Web Developers, discusses frontend architecture for complex, modular web applications with significant JavaScript elements.
Scoop.it!
When most people say they're building a "web app" they're talking about writing source code that describes an application that will run on the server and send rendered HTML to the browser. This definition seems a bit narrow and limiting. Plus, when I think of my favorite web apps they don't fit neatly into that box. The best web apps often have multiple interfaces and clients, some native, some web. Most play nicely with or completely integrate with other services. Generally web apps are good at solving some specific problem or provide some specific benefit and use the web to tie it all together.
Scoop.it!
JavaScript is having a great year. With the continuation of web development,Node.js, and even Apple adding JavaScript as a replacement for their AppleScript. You may be waiting until you have to learn JavaScript, but maybe you should learn JavaScript to make you a better developer. While many of us have been snickering, something amazing has happened. JavaScript has matured and prospered. It’s been adopted as a real language in many different scenarios. Certainly it’s biggest use is in client-side web development, but using JavaScript for mobile and server programming is getting more and more common.
Scoop.it!
Last year, I wrote about and recommended some great resources for getting good with andJavaScript. A year is a long time in Internet terms and I figured now was a good time for a refresh. JavaScript continues to explode in terms of adoption and being fully embraced, not only in the browser but also on the server. So it's about time we revisit the list and update it with good places to stay current.
Scoop.it!
This post will explain in a simple way how Javascript Closures work. We will go over these topics and frequently asked questions:
Scoop.it!
Scoop.it!
JavaScript OOP is baffling: on one hand, there is a simple core, on the other hand, there are some really weird things going on. I’ve been pondering for a long time how to explain it well and I think the best way to do so is via four layers: single objects, prototype chains, constructors, constructor inheritance. The first two layers are JavaScript’s simple OOP core, layers 3 and 4 are where the complications start.
Scoop.it!
This article details the way that property and variable lookups are performed in JavaScript and the resulting performance ramifications to be aware of.
Scoop.it!
I decided to spend the last couple of weeks introducing myself to some of the big MVC Javascript Frameworks that have gotten so much traction over the last couple of years. I sadly, have found the field littered with frameworks that happily violate the principle of Unobtrusive Javascript and am wondering — is there any solid MVC Javascript Framework that is clean and unobtrusive, will I need to keep rolling my own, or am I just a Luddite?
Scoop.it!
Type correctness does not guarantee program correctness, but type annotations are still cool, and there are actually lots of great tools for analysis of JavaScript applications. In this talk, you’ll learn how you can gain a lot more confidence in the correctness of your JavaScript applications, and probably a thing or two about why JavaScript’s dynamic types are actually a huge asset to application developers.
Scoop.it!
QUnit is an awesome unit testing framework for JavaScript that is written by the jQuery team for unit testing jQuery. This post describes a package I created to be able to run QUnit testing from within any .NET testing framework, and thus also from continuous integration servers. If you manage to achieve the difficult task of getting your JavaScript unit tests to run and return results within the context of your server-side testing framework then that is a huge win. I think it’s a win because it means you can run all of the tests for your application within the same context resulting in: That last point is important – this means you get continual regression testing of your JavaScript, and if multiple people are working on the same JavaScript then you get notification as soon as a bug is introduced as a side-effect of integrating the code.
Scoop.it!
There’s more to programming than just writing code. While unlikely, it is possible to write imperfect code the first time through, or have requirements change over time. In these cases, you have to refactor the code you’ve already written to fix mistakes and change functionality. You can go about refactoring your code in several ways; a small change can be done manually, but a larger change requires a tool to automate the task. Many programmers use regular expressions to modify their code - but are they the best choice? Programs such as sed that use regular expressions view your code as simply a blob of text - it’s 2014, we can do better than that! Grasp is a command line utility that allows you to search and replace your JavaScript code, with one important distinctive feature: it searches the structure behind your code (the abstract syntax tree), rather than simply the text you’ve written. That means Grasp is smart! It knows the difference between an if statement and an identifier, and it knows what parts make up those nodes (eg. an if statement has a test, a consequent, and optionally an alternative - the else). It combines this with an easy to understand syntax for searching and replacing, making it an incredibly powerful tool for refactoring your JavaScript code.
|
Scoop.it!
From
github
A collection of awesome browser-side JavaScript libraries, resources and shiny things.
Scoop.it!
Ariya Hidayat discusses principles for designing JavaScript APIs by observing the interactions between modules, particularly the influence of an interface on the code patterns.
Scoop.it!
Rich tools for instrumenting, analyzing, and visualizing web apps. Squeeze every drop of performance out of your code.
Scoop.it!
Sometimes we want to share objects by reference for performance and space reasons, but we don’t want them to be mutable. One motivation is when we want many objects to be able to share a common entity without worrying that one of them may inadvertently change the common entity. JavaScript provides a way to make properties immutable:
Scoop.it!
I’ve been wondering why DOM Mutation Observers, which can monitor changes to one or more DOM elements and return a report of what changed, aren’t used more often in the wild. DOM observers differ from the old Mutation Events in one special way: they’reasync and deliver mutations in batches asynchronously at the end of a micro-task rather than immediately after they occur. As Mutation Observers are async by design, they wait for the current stack to be empty before calling the callback we specify. This is useful because our callback isn’t called every single time a change is made to the DOM but only after all of the changes have been completed (or “soon”). This avoids the loss of synchrony as you don’t need to be concerned with FOUC before your observer has a chance to react.
Scoop.it!
From
vegibit
JavaScript is the programming language of the web, designed for the web to add behavior and interactivity to web pages. In this episode we’ll take a look at the very basics of the language. We’ll look at the core syntax of the language, where to place your JavaScript, what you can do with JavaScript, and what tools you will want to make use of in your JavaScript learning and programming. JavaScript used to be the frowned upon toy language of the world, but things have changed! Today with modern JavaScript frameworks and best practices, JavaScript is a bona fide enterprise level tool being put to use by the very most humble websites on up to super complex applications from the likes of the Google and Yahoo engineering teams. Contents:
Scoop.it!
If you are reading this I’d like to assume you know what Javascript is and the fact that it’s object oriented, what not many people know though is how to do the most common object oriented “things” in Javascript, such as inheritance, private functions and such. The fact that Javascript is prototype based and not class based is what makes it hard to get into for most programmers. If you come from Java, PHP, C#, C++, Python, Ruby or pretty much any language you’ll find objects in Javascript are a bit unique, and they certainly are but in a good way! * Prototypes
Scoop.it!
This post analyzes two versions of the same app, both the original (JavaScript) version and the Dart version. The original version is a proxy for any small JavaScript app, there's nothing particularly special about the original version, which is why it made for a good example.
Scoop.it!
How is JavaScript a minefield? Well, JavaScript has all sorts of pitfalls lurking for the developer. Each pitfall is like a mine in the minefield, silently waiting for you to accidentally step on it. Just like the minefield, JavaScript’s mines are hidden in plain sight. Entire books have been written about all the mines present in JavaScript. Maybe I’ll get into what some of those are in future blog posts. Now, if you are going to venture into a minefield, you need a way to avoid stepping on a mine. You need either a safe path through the minefield or a detailed map of all the mine locations. Douglas Crockford was trying to provide a safe path through the JavaScript minefield when he wrote JavaScript: The Good Parts. He did an admirable job at laying out a subset of the language that was sufficient but avoided many of the mines. However, the problem with any safe path through a minefield is that if you ever stray from the path, it doesn’t help at all. This article is Part 1 in a 6-Part Series.
Scoop.it!
The great/awesome/amazing thing about JS is that nobody wanted to go near it and in enterprise organisations they just wanted to stay in their safe little world of well organised layers of abstraction ordered by factory and XML super injection frameworks. That was great for people like me who wanted to get paid enterprise rates but didn't want to have to put up with layers of awful "best practises" and performance problems that came from the irrational fear of letting anybody who wasn't a DBA touch the database. Even better, when those performance problems arose, we could save the day by writing a front-end in JS that pretended they didn't exist and gave the users a great experience despite the shoddy workmanship on the backend.
Jan Hesse's insight:
see the comments
Scoop.it!
This book will teach you the basics of programming and Javascript. Whether you are an experienced programmer or not, this book is intended for everyone who wishes to learn the JavaScript programming language. In this first chapter, we'll learn the basics of programming and the Javascript language.
Scoop.it!
Writing software with JavaScript can be a lot like writing software in the dark. There is no static typing and no compiler, most errors are not found untill the code is executed. Hopefully that is in a test environment, and not when a user is working with your software. I think that a lot of emphasis should be on automated testing and analysing the code. At my current project, we have a rather nice setup in place to do this and guard our quality. The thing that caused a bit more work is that we are working in a Microsoft environment. So we have Visual Studio (2013) and TFS (2013). The rest of our project consists of C# and we like to work in Visual Studio. Any tooling that we add is preferred to integrate with our current tools. We already have gated checkins and continous integration builds for the .NET code. The CI build runs everything that is in the gated checkin build plus more (and slower) tests.
|
