This is a guest post by Zardosht Kasheff, Software Developer at Tokutek, a storage engine company that delivers 21st-Century capabilities to the leading open source data management platforms.

- analytical processing
- big data applications
- Data
- Data management
- Database
- Database management systems
- Databases
- hardware solution
- heavyweight solution
- inefficient solution
- Information
- MongoDB
- MySQL
- NoSQL
- NoSQL technologies
- OLAP
- Online transaction processing
- possible software solution
- possible solutions
- RAM
- Scalability
- Shard
- software developers
- software solutions
- storage device
- Technology
- Transaction processing
- Zardosht Kasheff

A discussion with artist and filmmaker Matthias Fritsch on why and how he is planning to produce a film about the story of my favourite internet meme: the Technoviking, a story that involves millions of users and that lately got him into court continue

- China
- Colorado
- Entertainment
- flash
- Germany
- Indiegogo
- internet culture
- internet hit
- Jeremiah Palecek
- life online
- Louis Vuitton
- Manchester
- Marc Horowitz
- Matthias Fritsch
- michael jackson
- online images
- Paris
- Paul Greenwood
- possible solutions
- simulation
- Spain
- United States
- Vernon Koekemoer
- Walsenburg
- web-celebrity
- YouTube

I've started doing interviews for internships, as I'm aspiring to get one this summer. However, I've done horrible on them.

I got A+ in my classes. I could implement and use data structures efficiently. I understood the algorithms presented to me. But I feel this wasn't/isn't an accurate measurement of my problem solving skills.

When presented with *new* algorithms or problems I have never encountered before, my brain stops working. I can rarely figure out the solutions all by myself. I always have to consult online references or other people's code, and I feel this doesn't make me better. I'm simply memorizing how other people got to it.

I've even bought books (Cracking the coding interview). I can't solve many of the problems they present. I have to read the solutions, then I get it (who wouldn't /eyeroll). But this is not helping me become better.

I've also worked on several projects related to web programming (creating user systems, forums) and game programming (simple 2D games with networking capabilities). I've learned a lot from these projects. But most of what I've learned concerns APIs and technologies (DirectX, MySQL, Winsock) and how they work. I rarely ran into having to implement or solve a puzzle type algorithms (maybe it's because I never got into doing advanced AI?) It's all been about understanding how a specific technology works. And if I had to use something complicated, I just used libraries which already implementing what I had to do.

**tl;dr - got good grades and understood all concepts in comp.sci. courses. Have had plenty of non-academic programming/project experience. Have read books on algorithms. BUT I still suck at them if presented with one I haven't previously seen the solution to.**

So does anyone have any tips on improving my algorithm skills that doesn't include trying to solve them and looking up a solution when I fail?

Thanks for all the advice. I really appreciate it. I'll start working on "easy" problems and go at them until I get at least a brute force solution. From there I'll try and clean up my code/solution. I'll try not to resort to looking at solutions in the same 48 hours of having started a problem at least.

Again, thanks for the advice. And for those of you who also struggle, it's good to know I'm not alone ;)

submitted by compsci_1234

[link] [34 comments]

- Algorithm
- Applied mathematics
- arbitrary solutions
- artificial intelligence
- brute force solution
- code/solution
- Complexity classes
- Computational complexity theory
- cryptography
- Dynamic programming
- good problem solving tool
- M.I.T
- machine learning
- Mathematical optimization
- Mathematics
- mathematics/optimized algorithms
- mathematics/optimized algorithms
- MySQL
- online judges
- online references
- Operations research
- P versus NP problem
- possible solutions
- puzzle type algorithms
- puzzle type algorithms
- Search algorithms
- search parameters
- software engineering
- Structural complexity theory
- technology works
- Theoretical computer science
- user systems

Dependency Injection practice could be awkward to follow using the framework Unity provides. In this article I will talk about some alternatives and specifically about my implementation of an Inversion Of Control container designed around Unity.

- ActionScript
- Associative containers
- C++
- C++ standard library
- Component-based software engineering
- Computer programming
- Computing
- container solution
- Dependency Injection
- Dependency injection
- GitHub
- good game development tool
- Inversion of control
- IoC
- Object-oriented design
- Object-oriented programming
- possible solutions
- programming
- pure game developer
- Rapid Application Development
- rapid application development tool
- Software architecture
- Software design patterns
- Software engineering
- Using Dependency Injection
- View

Facing criticism for presenting a limited view of life on the Pine Ridge reservation, Aaron Huey let its residents tell their own stories.

- Aaron Huey
- Aaron Huey
- AARON HUEY
- aesthetic product
- Badlands
- Cowbird
- Entertainment
- Ernesto Yerena
- flash
- James Estrin
- Jesuit-run Red Cloud High School
- John S. Knight
- Jonathan Harris
- Lakota
- Lakota people
- Mark St. Pierre
- National Geographic
- National Geographic
- Oglala Lakota
- Oglala Lakota
- Pine Ridge
- Pine Ridge Indian Reservation
- possible solutions
- Ramona White Plume
- SHEPARD FAIREY
- showcase
- Sioux
- Sioux Wars
- South Dakota
- Stanford University
- Stanford University
- the Times

EVE Online! Since the servers first rumbled to life nine years ago the deeply political, single-shard MMO has been a source of endless fascination for RPS, on a par with helicopters. *How do they stay in the air?*

But what’s happening in EVE? Last we heard, some of its most famous chaps were grumbling or rioting, followed by something that continues to feel like a controlled peace. We needed an update, and so it was that CCP sent over a crate containing Senior Producer Jon Lander, Lead Game Designer Kristoffer Touborg and Community Developer Sveinn Kjarval. Together, we would get to the truth.

(more…)

- Band of Brothers
- CCP
- ccp
- CSM
- Eve Mail
- Eve Online
- Feature
- Featured Articles
- Iceland
- internet connection
- interview
- Jon Lander
- Kristoffer Touborg
- Kristoffer Touborg
- official eve site
- online hours
- others products
- possible solutions
- PS3
- Reykjavik
- RockPaperShotgun
- RPS Holdings
- Sony
- Sveinn Kjarval
- United Kingdom
- want asteroid mining
- YouTube

Dynamic programming is both a mathematical optimization method and a computer programming method. In both contexts it refers to simplifying a complicated problem by breaking it down into simpler subproblems in a recursive manner. While some decision problems cannot be taken apart this way, decisions that span several points in time do often break apart recursively; Bellman called this the "Principle of Optimality". Likewise, in computer science, a problem that can be broken down recursively is said to have optimal substructure.

If subproblems can be nested recursively inside larger problems, so that dynamic programming methods are applicable, then there is a relation between the value of the larger problem and the values of the subproblems.^{[5]} In the optimization literature this relationship is called the Bellman equation.

### Dynamic programming in mathematical optimization

In terms of mathematical optimization, dynamic programming usually refers to simplifying a decision by breaking it down into a sequence of decision steps over time. This is done by defining a sequence of **value functions** V_{1}, *V*_{2}, ..., *V*_{n}, with an argument *y* representing the **state** of the system at times *i* from 1 to *n*. The definition of V_{n}(y) is the value obtained in state *y* at the last time *n*. The values V_{i} at earlier times *i* = *n* −1, *n* − 2, ..., 2, 1 can be found by working backwards, using a recursive relationship called the Bellman equation. For *i* = 2, ..., *n*, *V*_{i−1} at any state *y* is calculated from V_{i} by maximizing a simple function (usually the sum) of the gain from decision *i* − 1 and the function *V*_{i} at the new state of the system if this decision is made. Since *V*_{i} has already been calculated for the needed states, the above operation yields *V*_{i−1} for those states. Finally, *V*_{1} at the initial state of the system is the value of the optimal solution. The optimal values of the decision variables can be recovered, one by one, by tracking back the calculations already performed.

### Dynamic programming in computer programming

There are two key attributes that a problem must have in order for dynamic programming to be applicable: optimal substructure and overlapping subproblems. However, when the overlapping problems are much smaller than the original problem, the strategy is called "divide and conquer" rather than "dynamic programming". This is why mergesort, quicksort, and finding all matches of a regular expression are not classified as dynamic programming problems.

*Optimal substructure* means that the solution to a given optimization problem can be obtained by the combination of optimal solutions to its subproblems. Consequently, the first step towards devising a dynamic programming solution is to check whether the problem exhibits such optimal substructure. Such optimal substructures are usually described by means of recursion. For example, given a graph *G=(V,E)*, the shortest path *p* from a vertex *u* to a vertex *v* exhibits optimal substructure: take any intermediate vertex *w* on this shortest path *p*. If *p* is truly the shortest path, then the path *p _{1}* from

*u*to

*w*and

*p*from

_{2}*w*to

*v*are indeed the shortest paths between the corresponding vertices (by the simple cut-and-paste argument described in CLRS). Hence, one can easily formulate the solution for finding shortest paths in a recursive manner, which is what the Bellman-Ford algorithm or the Floyd-Warshall algorithm does.

*Overlapping* subproblems means that the space of subproblems must be small, that is, any recursive algorithm solving the problem should solve the same subproblems over and over, rather than generating new subproblems. For example, consider the recursive formulation for generating the Fibonacci series: *F*_{i} = *F*_{i−1} + *F*_{i−2}, with base case *F*_{1} = *F*_{2} = 1. Then *F*_{43} = *F*_{42} + *F*_{41}, and *F*_{42} = *F*_{41} + *F*_{40}. Now *F*_{41} is being solved in the recursive subtrees of both *F*_{43} as well as *F*_{42}. Even though the total number of subproblems is actually small (only 43 of them), we end up solving the same problems over and over if we adopt a naive recursive solution such as this. Dynamic programming takes account of this fact and solves each subproblem only once. Note that the subproblems must be only *slightly* smaller (typically taken to mean a constant additive factor^{[citation needed]}) than the larger problem; when they are a multiplicative factor smaller the problem is no longer classified as dynamic programming.

**Figure 2.** The subproblem graph for the Fibonacci sequence. The fact that it is not a tree indicates overlapping subproblems.

This can be achieved in either of two ways:^{[citation needed]}

*Top-down approach*: This is the direct fall-out of the recursive formulation of any problem. If the solution to any problem can be formulated recursively using the solution to its subproblems, and if its subproblems are overlapping, then one can easily memoize or store the solutions to the subproblems in a table. Whenever we attempt to solve a new subproblem, we first check the table to see if it is already solved. If a solution has been recorded, we can use it directly, otherwise we solve the subproblem and add its solution to the table.

*Bottom-up approach*: Once we formulate the solution to a problem recursively as in terms of its subproblems, we can try reformulating the problem in a bottom-up fashion: try solving the subproblems first and use their solutions to build-on and arrive at solutions to bigger subproblems. This is also usually done in a tabular form by iteratively generating solutions to bigger and bigger subproblems by using the solutions to small subproblems. For example, if we already know the values of F_{41}and F_{40}, we can directly calculate the value of F_{42}.

Some programming languages can automatically memoize the result of a function call with a particular set of arguments, in order to speed up call-by-name evaluation (this mechanism is referred to as *call-by-need*). Some languages make it possible portably (e.g. Scheme, Common Lisp or Perl), some need special extensions (e.g. C++, see^{[6]}). Some languages have automatic memoization built in, such as tabled Prolog and J, which supports memoization with the *M.* adverb^{[7]}. In any case, this is only possible for a referentially transparent function.

## Algorithms that use dynamic programming

- Recurrent solutions to Lattice models for protein-DNA binding
- Backward induction as a solution method for finite-horizon discrete-time dynamic optimization problems
- Method of undetermined coefficients can be used to solve the Bellman equation in infinite-horizon, discrete-time, discounted, time-invariant dynamic optimization problems
- Many string algorithms including longest common subsequence, longest increasing subsequence, longest common substring, Levenshtein distance (edit distance).
- Many algorithmic problems on graphs can be solved efficiently for graphs of bounded treewidth or bounded clique-width by using dynamic programming on a tree decomposition of the graph.
- The Cocke–Younger–Kasami (CYK) algorithm which determines whether and how a given string can be generated by a given context-free grammar
- Knuth's word wrapping algorithm that minimizes raggedness when word wrapping text
- The use of transposition tables and refutation tables in computer chess
- The Viterbi algorithm (used for hidden Markov models)
- The Earley algorithm (a type of chart parser)
- The Needleman–Wunsch and other algorithms used in bioinformatics, including sequence alignment, structural alignment, RNA structure prediction.
- Floyd's All-Pairs shortest path algorithm
- Optimizing the order for chain matrix multiplication
- Pseudopolynomial time algorithms for the Subset Sum and Knapsack and Partition problem Problems
- The dynamic time warping algorithm for computing the global distance between two time series
- The Selinger (a.k.a. System R) algorithm for relational database query optimization
- De Boor algorithm for evaluating B-spline curves
- Duckworth–Lewis method for resolving the problem when games of cricket are interrupted
- The Value Iteration method for solving Markov decision processes
- Some graphic image edge following selection methods such as the "magnet" selection tool in Photoshop
- Some methods for solving interval scheduling problems
- Some methods for solving word wrap problems
- Some methods for solving the travelling salesman problem, either exactly (in exponential time) or approximately (e.g. via the bitonic tour)
- Recursive least squares method
- Beat tracking in Music Information Retrieval.
- Adaptive Critic training strategy for artificial neural networks
- Stereo algorithms for solving the Correspondence problem used in stereo vision.
- Seam carving (content aware image resizing)
- The Bellman–Ford algorithm for finding the shortest distance in a graph.
- Some approximate solution methods for the linear search problem.
- Kadane's algorithm for the Maximum subarray problem.

## See also

- Algorithm
- Bellman equation
- cs
- Dynamic programming
- dynamic programming solution
- Equations
- exponential time algorithm
- exponential time algorithm
- Floyd-Warshall algorithm
- Ford
- Hanoi
- interactive online facility
- Mathematical optimization
- Mathematics
- naive recursive solution
- Operations research
- Optimal control
- Optimal substructure
- Optimization
- overall solution
- Overlapping subproblem
- Perl
- possible solutions
- programming
- Prolog
- recursive algorithm
- recursive algorithm
- Richard Bellman
- Shortest path problem

Every now and then, we look around, select **fresh free high-quality fonts** and present them to you in a brief overview. The choice is enormous, so the time you need to find them is usually time you should be investing in your projects. We search for them and find them so that you don’t have to.

In this selection, we’re pleased to present Homestead, Bree Serif, Levanderia, Valencia, Nomed Font, Carton and other quality fonts. Please note that while most fonts are available for commercial projects, some are for personal use only and are clearly marked as such in their descriptions. Also, please read the licensing agreements carefully before using the fonts; they may change from time to time.

### Free Fonts

Homestead

Homestead is a very distinctive Slab Serif typeface that leaves a lasting impression with its geometric forms and a modern, progressive look. The family is available in 6 weights: Regular, Inline Display, One, Two and Three. Released by the Lost Type foundry with the “name-your-price” pricing scheme. Homestead can be used freely for any personal or commercial use.

Bree Serif Regular

This typeface is the serif cousin of the playful, charming and versatile type family *Bree* which was designed by Veronika Burian and José Scaglione back in 2008. Actually, *Bree* is also the typeface used in the Smashing Cartoons. An italic font weight of Bree Serif should be available very soon. Released under the liberal OFL license (via Typografie.info).

Lavanderia

Lavanderia is a script font based on lettering found on Laundromat windows of San Francisco’s Mission District. It features numerous OpenType features such as swashes, titling alternates, figures, stylistic alternates, ligatures. It is available in three weights, with Uppercase, Lowercase, Numerals and Punctuation sets. Designed by the talented type designer James T. Edmondson and released by the Lost Type Co-Op foundry. Free for personal and commercial use.

RBNo2

This new gothic sans serif font was inspired by the late 19th century industrial fonts that contained german roots regarding straightness and geometry. Combined with other sans serifs, slab serifs and serif fonts, it catches the eye when used in headlines and short copy texts. Alternate versions turn the font into a perfect partner for modern, technical and contemporary impressions as well as high-quality, luxury and timeless environments. Free to use in commercial and non-commercial projects. Designed by Rene Bieder.

Cassannet

Cassannet is a geometrical art deco typeface available in Regular, Bold and Outline weights, based on lettering seen on Cassandre posters. This typeface contains ligatures, capitals, numbers, small capitals and also titling alternates. You can pay a random amount of money or alternatively send out a tweet or a Facebook post to download the fonts for free.

Valencia

Valencia is a condensed, art-deco inspired typeface that includes five weights, ranging from hairline to black, with matching obliques for each weight. The typeface has a nice corporate vintage look which makes it a great fit for large headlines and prints as well as any collateral or stationery. Valencia’s distinctive appearance stems from its low horizontal crossbars and its full-circle curves. Released by the Lost-Type Co-Op foundry with the “name-your-price” pricing scheme and hence freely available for personal and commercial use.

Jura

Jura is an elegant serif typeface with narrow proportions and distinguishing details. The rounded, wedge-shaped serifs offer a contemporary feel and also achieve to maintain legibility even with its range of small sizes. This typeface is available in four weights: Regular, Italic, Bold and Bold Italic and is available for free download and use.

Nomed Font

Nomed Font is a free typeface that can help you achieve a modern and sophisticated look in your designs. The triangular geometric shapes may be a bit hard to read but that’s exactly the highlight of this particular style, and it makes the typography unique and original.

Carton

This typeface, designed by Nick McCosker, is a strong yet sensitive slab-serif inspired by letterpress. Its sturdy appearance makes it a perfect fit for posters, headings and taglines, in both classic and contemporary contexts. Released by the Lost Type Co-Op under the “name-your-price” pricing scheme.

Novecento (*Registration on MyFonts is required!*)

This typeface is an uppercase-only font family with some pretty impressive geometric forms that have been inspired by historical European typographic tendencies. It was designed to be used mostly for headlines, visual identities or short sentences — both in big and small sizes. The family contains 471 glyphs and 32 font weights whereas six of the font weights of the *wide*-version (Light, Book, Normal, Medium, Demibold and Bold) are available for free download and use.

Fjord

Fjord is serif typeface that has specifically been designed for book publications. It is intended to be used in long texts and in relatively small print size. Fjord features sturdy construction, prominent serifs, low-contrast modulation and long elegant ascenders as well as descenders relative to the ‘x’ height. Fjord performs well in sizes starting from 12px and higher; nevertheless, it can also be a distinctive font choice for larger text headlines and in corporate design. This serif typeface include Cyrillic and Greek characters and is available at Google Web Fonts. It has been released under the SIL Open Font License, 1.1. Feel free to take a look at the designer’s free font Armata as well.

Hero

Hero is a crisp geometrical typeface applicable for any type of use: print, Web, logos, posters, booklets. This typeface contains 162 characters and is free for personal and commercial use. Available in the OpenType format for PC and Mac.

Otama e.p.

Here’s a quite confident typeface to use for expensive and fashionable designs. Strong steams and thin serifs shows similarities to the well-known traditional Didot typeface. This typeface is free for personal and commercial use.

Ribbon

This typeface is a geometric display face which includes OpenType features for an alternate alphabet. The family contains sets for Uppercase, Numerals and Punctuation. Released by the Lost Type Co-Op under the “name-your-price” pricing scheme and designed by Dan Gneiding. If you decide to buy the font for $30 or more, you will get a beautiful Ribbon Specimen Book as well.

Movavi

Movavi is a sans serif font that is available only in the font weights Black and Black Italic. Obviously, the typeface wouldn’t work for body copy, but it might work nicely in short headings or “groovy” art works. Available for free download and use on PC and Mac.

Satellite

Satellite is a geometric sans serif font designed by Matt Yow. The typeface can be a great fit for short headlines, short body copy or slogans. Released under the SIL Open Font License.

Open Sans

Open Sans is a very clean font family by Ascender Fonts. It includes ten styles (Light, Regular, Italic, Semibold, Bold, Bold Italic, Extrabold) and each one consists of more than 900 glyphs: Latin, Greek, Cyrillic, many of the regular diacrytic letters as well as “hanging” numbers. Also available at Google Web Fonts and released under the Apache License version 2.

Mosaic Leaf

The glyphs of this expressive typeface are built out of leaves of different sizes. Mosaic Leaf also contains numbers, punctuation and currency symbols. The .zip-package contains PDF, OTF and TTF files; the fonts support Western and Central European encoding, and also Baltic, Nordic and Turkish. The typeface is free to use in commercial and non-commercial projects. Designed and prepared by Lukasz Kulakowski and Zbyszek Czapnik.

Amaranth

Amaranth is a sans serif font family of four basic styles (regular, italic, bold, bold italic) with individually shaped letter forms that makes typeface more playful. Suitable for both Web and print, longer texts and headings. Available at Google Web Fonts and licensed under the SIT OpenType License. Image credit and source: dersven.

Siruca Pictograms

A pictogram open source font made as a part of Siruca signage system designed by Fabrizio Schiavi. The font contains many picograms related to sport, signage, home, social meetings, free time activities and business.

Erler Dingbats

For the first time in the entire history of Unicode standard, the full encoding range for dingbats is now covered by a complete, contemporary quality font. FF Dingbats 2.0 features more than 800 glyphs and is mainly a tool for professional designers and has been created for everyday communication purposes. It includes a wide range of popular symbols and pictograms such as arrows, pens, phones, stars, crosses and checkmarks, plus three sets of cameo figures on round backgrounds. Free of charge. (via fontblog)

#### Further Free Fonts

SD Sansimillia

SD Sansimillia is a playful, yet elegant typeface suitable for many different applications. Originally cut for a local advertising brand, SD Sansimillia is inspired by the Antenna Family built by Cyrus Highsmith in 2007 as well as Erik Spiekermann’s FF Din Family cut in 1994. It is issued in regular, bold and black weights.

Mimic Roman

Mimic Roman is a modern sans serif face with evenly balanced strokes and a counter on a slight angle, giving it a 1950s retro look.

Roboto

Roboto Family is a linear sans serif font, available in 8 different styles of which each includes more than 900 glyphs — Greek and Cyrillic, too. This font was designed by Google for Andorid and is licensed under the Google Android License.

Mate

An elegant serif font designed by Eduardo Tunni. This typeface was primarily designed to be used in longer body copies in printed material. It is simple in structure and has sharp as well as generous counter-shapes which create a medium texture that calls for page color. It can also be used as display typography and is available at Google Web Fonts.

### Last Click

Shape Type

If you are passionate about typography and have fun experimenting with glyphs, then you will certainly like the rather unusual type-design game created by the interaction designer Mark MacKay. The idea of this JavaScript-based letter-shaping game is simple: you get 10 modified letters from various classic typefaces, and you have to try to make them right by dragging curves along their axes. It’s an engaging way to explore what makes or breaks a glyph.

Font-Bot Project

It is time for your favorite font to stand its ground. The idea is to build robots out of a type face, showcase them and hope others put together a potential opponent. Once there are two font-bots ready to compete against each other, only thing left would be to “let the battle begin!” Participating is not hard, the rules are clear: all robots must be built of type alone (letters A to Z). Let’s see if your font has what it takes to defend its corner. Fight!

#### Further Resources

- Lost Type Co-Op

The Lost Type Co-Op is a Pay-What-You-Want Type foundry. Users have the opportunity to pay whatever they like for a font; you can type in ‘$0′ for a free download. 100% of all funds from these sales go directly to the designers of the fonts themselves, respectively. - The League of Moveable Type

The open-source type movement for bringing high-quality tyepfaces to the Web. The creators of the project keep releasing quality fonts every now and then so be sure to stay tuned! - Google Web Fonts

A growing directory of hundreds of free, open-source fonts optimized for the Web. Google also provides ready-to-use snippets for integrating the fonts to your website. - Typography and Free Fonts on Smashing Magazine

An overview of typography-related articles and free font round-ups on Smashing Magazine.

We sincerely appreciate the time and effort of all type designers featured in this post. Please keep in mind that type design is a time-consuming craft which truly deserves reward and support. Please consider supporting type designers who create and release amazing typefaces for all of us to use.

*(vf) (il)*

© Smashing Editorial Team for Smashing Magazine, 2012.

- Adobe
- Akzidenz-Grotesk
- Android
- Ayouni
- Bree Serif
- Cyrus Highsmith
- Dan Gneiding
- Digital typography
- Din Family
- Droid
- Eduardo Tunni
- Erik Spiekermann
- Ezequiel Lancelotti
- Font
- fonts
- For the first time
- Free Fonts
- Freiburg
- Germany
- Graphic design
- James T. Edmondson
- Julianne Bueno
- local advertising brand
- Mark MacKay
- Matt Yow
- Nick McCosker
- Paul Langston
- possible solutions
- Publishing
- Raphael Pudlowski
- Rene Bieder
- San Francisco
- Sans-serif
- Simon Clavey
- Smashing Magazine
- TrueType
- Typeface
- Typesetting
- typography
- Typography
- Valencia
- Veronika Burian
- web fonts
- Web typography
- Zide