Just a quick note: the folks at Rackspace created a pretty neat infographic to take customers through a simple decision making process on a route to the solution that’s right for them. Check it out and let us know what you think:
Infographic by Rackspace Hosting
A new jobs board has been launched as part of the new web site for the UK Game Developers trade association, TIGA. Built on the engine of DS Interactive Ltd’s very own Games Job Board the site boasts 248 senior level and 182 mid level games industry jobs in the UK (175), China (45), Germany (31), Sweden (23), Irealnd (22), and Canada (19) and many other countries. Vist the new site at http://www.tiga.org/jobs
This is the second part in the series of 2 tutorials on how to create custom designs for your iPhone app. You can view Part 1 here. In this tutorial, we shall design a ViewController similar to the image below. The ViewController will have a custom UIBarButtonItem that replaces the standard back button and a transparent UINavigationBar that allows some of the underlying view to show through.
At the end of this post, you will be able to download the sample project that was used in the videos. Let’s get right to it.
In this video, I will add some tap gestures to the sub views at the bottom so when they are tapped, a new ViewController is pushed into the screen. You can change the way the ViewController is displayed using different animation styles. For this tutorial, we will use the standard slide-in animation.
In this video, you will learn how to design a custom UIViewController that shows a cover image for an article. The designs used are a subset of the Newsreader iPhone App Design Template.It will also have some metadata about the author, and the date the article was published. This new View will have a transparent navigation bar which you will see in the next video. Note: The video starts off resized and you may not be able to see much. Please wait until about 30 seconds into it and it will be correctly resized.
Talk about saving the best for last. If you have always wanted to spruce up your Navigation Bar, this is how to do it. This video will teach you how to create a transparent UINavigationBar and the custom back button. You can download the resources from this link.
Here is the link to download the sample project. If you have any questions, please let me know in the comments.
Did this tutorial give you exactly what you were looking for? You can decide what comes up in new tutorials by letting us know what you would like to learn. All you have to do is take two minutes to answer these questions:
Zero Bundle is an awesome set of resources, filled with free design goodies, icons, textures, UI kits, graphic elements for mobile development and much more! You’ll want to get your hands on this one soon as it will only be available for a very short time!
Larsson Patrik
A power pack of premium quality freebies that contains 12 premium elements (one of them is a Zero Bundle exclusive). Pack includes: Patricons v.1, PatriGlyps Set 1, buttons, login form, wood panel box, social buttons and more. For more freebies visit the authors’ website below and subscribe to his site for more exclusive freebies.
Ben Bate
The pack includes a variety of user interface elements, ranging from sleek navigation bars and login forms to site designs and icons. Included are a full Apple like menu, iPad icon, login form, and menu with notifications. Ben is a freelance designer from Plymouth, England who specialises in Graphic, UI and Web Design.
Purty Pixels
Here’s a set of PurtyPixels freebies that are crafted with oodles of fun and buckets of joy. There’s a bit of buttons (some of which are quite crazy), some author pro-esque buttons, a full fledged UI kit from the dark side and a fantastically super set of badges. PurtyPixels is a super awesome, fantastically free collection of PSD design resources designed by Richard Tabor.
+ tons of other digital goods from top notch graphic designers! Check it out and grab your free copy now!
In the summer of 2011, DJ Maneesh and DJ Rachman moved to Berlin to attempt to become DJs in Berlin. They had no experience.
We filmed this in our attempt to become well known DJs in just 90 days. In our first episode, Building the Mobile Disco, we built a system that allowed us to throw parties anywhere in the city.
In the second episode, Destination: Subway Station Rave, we showed the sort of parties we threw in Metro stations and on the street.
Today, you’ll see our failed Bicycle Cart, where we attempted to improve our outdoor party center—miserably. Check it out. PLEASE: Share this video with your friends!
Ep. 3 – Building the Failed Bicycle Cart. 90 Days to Becoming a Berlin DJ is a post from: Hack The System
Question often comes up whether tuples can have traditional iterators? In general, the answer is: No! They cannot. That’s because tuples typically contain different types and traditional iterators, which are modeled after pointers, can not dereference to objects of multiple types. However, homogeneous tuples can have iterators. So I thought it would be a fun exercise to write one. I wonder why one would use a homogeneous tuples instead of just plain arrays. But lets do it anyways because we can.
Although this exercise sounds rather naive and unnecessary, I stumbled upon two very interesting topics along the way.
From this point onward a tuple is assumed to be a homogeneous tuple. First thing we need is a way of accessing tuple’s contents using a run-time integer instead of a compile-time integer. We need an adapter that uses a run-time integer index to return the n-th element in a homogeneous tuple. If n is larger than the bounds of the tuple, the adapter will throw a std::out_of_range exception.
template <typename Tuple, size_t I = std::tuple_size<Tuple>::value-1>class TupleAt{ typedef typename std::tuple_element<0, Tuple>::type T;
public: static T & get(Tuple & tuple, size_t index) { return (index == I)? std::get<I>(tuple) : TupleAt<Tuple, I-1>::get(tuple, index); }};
template <typename Tuple>class TupleAt<Tuple, 0>{ typedef typename std::tuple_element<0, Tuple>::type T; public:
static T & get(Tuple & tuple, size_t index) { if(index == 0) return std::get<0>(tuple); else throw std::out_of_range("Tuple iterator dereferenced out of valid range."); }};
The TupleAt template takes the type of the tuple and its size as template parameters. It assumes that the type of the first element is also the type of the rest of the elements in the tuple (i.e. a homogeneous tuple). TupleAt::get function returns a reference to the n-th element in the tuple. It does that using repeated comparisons from the size of the tuple (std::tuple_size<Tuple>::value) down to zero. TupleAt is specialized for zero so that the recursion ends. If the index does not fall in the expected range, std::out_of_range exception is thrown.
Note that this access pattern is linear in complexity. For a tuple of N elements, it may take up to N comparisons to return the right element.
I created a tuple_array class to provide array-like access to the elements of the tuple. It uses TupleAt internally.
template <typename... T>class tuple_array : public std::tuple<T...>{ typedef std::tuple<T...> Tuple; typedef typename std::tuple_element<0, Tuple>::type HeadType; enum { TUPLE_SIZE = std::tuple_size<tuple>::value };
HeadType * ref_; size_t last_;
public: USING(tuple_array, Tuple) { ref_ = & TupleAt<tuple>::get(*this, TUPLE_SIZE-1); last_ = TUPLE_SIZE-1; }
HeadType & operator [] (size_t index) { if(last_ != index) { ref_ = & TupleAt<tuple>::get(*this, index); last_ = index; } return *ref_; }};
Class tuple_array inherits from std::tuple and just provides operator [] function. It always returns a reference to HeadType typedef, which is the type of the first element in the tuple. To improve efficiency, the tuple_array class caches a pointer to the last dereferenced index in the tuple. std::tuple has a zillion constructors to create a tuple. To avoid repeating the constructors in the derived tuple_array class, I wanted to use inherited constructors. However, g++ 4.7 does not support it at this moment. So I’m using a variadic template constructor to mimic the behavior of inherited constructors.
#define USING(Dervied, Base) \ template<typename ...Args, \ typename = typename std::enable_if \ < \ std::is_constructible<Base, Args...>::value \ >::type> \ Dervied(Args &&...args) \ : Base(std::forward<Args>(args)...) \
The inherited constructor trick is captured in a macro, which I stole shamelessly from here. The USING macro defines a variadic template constructor and forwards all the arguments to the underlying base constructor. To avoid being overly greedy, it enables instantiation only if the base is constructible from the given parameters. std::is_constructible<Base, Args…>::value provides a neat way of checking that at compile-time.
Finally, we need a simple function to create the tuple_array. Function make_tuple_array is a factory function to create tuple_arrays from a list of arguments. Note how it uses the uniform initialization syntax without specifying the actual type. Using make_tuple_array is just like an array. However, note that element access is linear and not constant-time.
template <typename... T>tuple_array<T...> make_tuple_array(T... args){ return { std::forward< T&& >(args)... };}
int main(void){ auto ta = make_tuple_array(20, 30, 40); printf("%d %d %d", ta[0], ta[1], ta[2]); // prints 20 30 40}
Now lets turn our attention to iterators.
What category would an iterator for homogeneous tuple belong? Random access? Bidirectional? It appears to me that the homogeneous tuple iterator could simply use an internal index to remember what position it is at and use the TupleAt::get to return the element when dereferenced. Arbitrary arithmetic can be performed in constant-time on the internal index to move the iterator. This indicates that the iterator is a random access iterator.
However, the dereference function is not constant-time as discussed earlier. As a result, it is not a random access iterator. Clearly, traversal is random access but element access is not. Existing iterator categories do not support this distinction. The standard random access iterator [5] requires all operations to be amortized constant time.
What we really need is a way to distinguish between the categories of element access and the categories of traversal. This is precisely the point of new iterator concepts in boost.
For now, we’ll just consider that the iterator for homogeneous tuple is a random access iterator. Here is how it looks like with a lot of boilerplate overloaded operators.
template <typename Tuple>class tuple_iterator : public std::iterator<std::random_access_iterator_tag, typename std::tuple_element<0, Tuple>::type>{ typedef typename std::tuple_element<0, Tuple>::type T; enum { TUPLE_SIZE = std::tuple_size<Tuple>::value };
Tuple * tuple; int current_; int last_; T * ref_;
T * update_ref() { if(current_ != last_) { ref_ = & TupleAt<Tuple>::get(*tuple, current_); last_ = current_; } return ref_; }
public:
typedef int difference_type;
explicit tuple_iterator(Tuple & t, int i = TUPLE_SIZE) : tuple(&t), current_(i), last_(i-1), ref_(&TupleAt<Tuple>::get(*tuple, last_)) {} T & operator *() { return *update_ref(); } T * operator ->() { return update_ref(); } T & operator [] (int offset) { return TupleAt<Tuple>::get(*tuple, current_+offset); } tuple_iterator & operator ++ () { if(current_ < TUPLE_SIZE) ++current_; return *this; } tuple_iterator operator ++ (int) { tuple_iterator temp(*this); ++(*this); return temp; } tuple_iterator & operator -- () { if(current_ >= 0) --current_; return *this; } tuple_iterator operator -- (int) { tuple_iterator temp(*this); --(*this); return temp; } tuple_iterator operator - (int i) const { tuple_iterator temp(*tuple, current_-i); return temp; } tuple_iterator & operator -= (int i) { current_-=i; return *this; } tuple_iterator operator + (int i) const { tuple_iterator temp(*tuple, current_+i); return temp; } tuple_iterator & operator += (int i) { current_+=i; return *this; } difference_type operator - (const tuple_iterator & ti) const { return current_ - ti.current_; } bool operator < (const tuple_iterator &ti) const { return index < ti.index; } bool operator > (const tuple_iterator &ti) const { return index > ti.index; } bool operator <= (const tuple_iterator &ti) const { return index <= ti.index; } bool operator >= (const tuple_iterator &ti) const { return index >= ti.index; } bool operator == (tuple_iterator const & ti) const { return (tuple == ti.tuple) && (index == ti.index); } bool operator != (tuple_iterator const & ti) const { return !(*this == ti); }};
template <>class tuple_iterator <std::tuple<>>{ public: tuple_iterator(std::tuple<>, size_t i = 0) {}};
The tuple_iterator class provides the usual typedefs (e.g., difference_type, value_type, pointer, reference, and iterator_category) and overloaded operators (e.g., *, ->, [], +, -, +=, -=, -, +, <, >, <=, >=, ==, !=) to support the requirements of random access iterator. Just like tuple_array class it caches a pointer to the last element that was dereferenced. It goes through O(N) comparisons only if the tuple iterator is dereferenced at a different index than what is cached. A specialization of tuple_iterator for empty tuple is also provided. It has no members other than a constructor because there is nothing to dereference to!
Finally, we need a way to create the begin and end iterator from a non-empty tuple. We add the corresponding functions.
template <typename... Args>tuple_iterator <std::tuple<Args...>> begin(std::tuple <Args...> &t){ return tuple_iterator <std::tuple<Args...>>(t, 0);}
template <typename... Args>tuple_iterator <std::tuple<Args...>> end(std::tuple <Args...> &t){ return tuple_iterator <std::tuple<Args...>>(t);}
If no index is passed to the iterator constructor, it points to the end of the tuple. The internal index of such an iterator is same as the size of the tuple. An iterator at the beginning has index = 0 — the first element. Using the iterators is now straightforward. I do not discuss constant and reverse iterators here.
int main(void){ auto tuple = std::make_tuple(10, 20, 30, 40); auto ta = make_tuple_array(4, 2, 1);
std::copy(begin(tuple), end(tuple), std::ostream_iterator<int>(std::cout, " ")); std::sort(begin(ta), end(ta));
for(int i : ta) { std::cout << i << std::endl; }
return 0;}
I think, this rather naive exercise turned out to be quite interesting. Hopefully, you enjoyed as much as I did.
Welcome to the inaugural episode of the Hack The System show!
You should subscribe to this show on iTunes.
Starting today, you’re going to get access to interviews with the worlds’ foremost experts on blogging, lifestyle design, traveling, and life/system hacking. In short–you’re going to learn how to kick ass.
In this episode, I sit down with Jonathan Mead of Illuminated Mind, where he blows my mind with his ideas about joint webinars and building a brand. This interview literally changed the way I do business.
Jonathan teaches people how to change their lives through his Trailblazer course, where he helps students discover, and implement, their passions. Check out his awesome Trailblazer video.
Listen to the podcast here:
Watch it here:
This podcast can be seen on iTunes. Click here to follow it via iTunes (and automatically sync it to your iPod)
00:25 – Welcome Jonathan Mead!
1:05 – Importance of branding in business and in life
2:10 – The feeling of getting success stories from people you’ve inspired
3:10 – Feeling trapped in your job
3:45 – How to escape feeling trapped
6:00 – What was the first step for Jonathan towards finding his passion
7:00 – What did Jonathan do before blogging?
8:50 – Mentors that help you design your life
9:55 – How Jonathan helped one woman achieve her passion
10:55 – How to reach out and network with people who are more powerful than you
12:00 – more tips on networking
12:50 – How Jonathan built his readership by leveraging others’ communities
13:30 – Offering your skills for free to network
From 15:50 – 25:00 == Some of the best tactics for networking an generating revenue that I’ve ever heard
15:50 – How to reverse engineer situations to meet important people
16:30 – Specific tactics for making important people notice you
18:40 – How Jonathan built such a large email list
21:05 – Jonathan’s current tactics for success: building partnerships
21:20 – Doing co-webinars (This advice BLEW MY MIND)
22:00 – Exactly how to leverage other peoples’ audiences to make money and build your subscriber list
25:00 – Getting excellent design for ebooks and web sites
25:20 – For people who are just getting started, what’s the next step to become successful?
26:00 – The importance and how to of running your blog like a business
27:40 – What about building an online business/passion without blogging?
28:50 – Jonathan talks about his product, Trailblazer
Hack The System Podcast: Episode 1 with Jonathan Mead is a post from: Hack The System
Wow this must really give Apple something to think about, perhaps it is time to listen to the jailbreak community and start implementing their ideas in the next iOS update. according to 9to5Mac.com just three days after the release of “Absinthe,” the much anticipated free unteathered jailbreak tool for the iPhone 4S and iPad 2, the site announced that 1 million people jailbroke their A5 device in under three days.
Those numbers are pretty amazing, the reason why the Chronic-Dev team can pinpoint the exact numbers is that Cydia, the app marketplace that comes with the jailbreak offers some pretty neat statistical data. According to the team the jailbreak was installed 491,325 on an iPhone 4S; 308,967 on an iPad 2; and, 152,940 on an iPad 2 that had been previously jailbroken (iOS 4).
Like always, the Chronic-Dev team reminds you not upgrade off of 5.0.1 if you intend to keep the jailbreak. For those looking to jailbreak their device you can find the tools needed here.
Did you jailbreak your A5 device this weekend?
Sober living for women programs provide an important environment for the woman that is trying to hard to make major changes. Leading a life of sobriety does not simply happen for those that have lived a life of addiction for years. Here are ways that these programs can be beneficial and more information about sober living for women.
Residential Location
When you live in a typical sobriety home, you are in a normal neighborhood and not a hospital or institution. You may be living with several other women in the home. You need to pay rent each month and you will be sharing a bedroom in most cases. Your living expenses will be affordable but you must have a job if you are able bodied.
Rules
Sobriety houses have rules that must be adhered to. For example, there is absolutely no tolerance for any drugs or alcohol use by the tenants. They also must conduct themselves in a manner that does not cause conflict or injury to others. If these rules are violated, the offending resident will be removed from the home with no notice.
Drug Testing
As a sobriety home resident, you must agree to random drug testing programs. There are also curfews and house rules that you must obey. These facilities are not for people entering detox as they require special assistance. These homes are for people who are already into their sobriety and need help adjusting to healthy, day-to-day living.
Learning Opportunity
Sober living for women facilities provide a learning experience for the people who live there. They get the chance to focus on and experience a life without drugs or alcohol. For many people, this is something entirely new in their lives and they will need help and support for these important life changes. Everyone in the house will be supportive and understanding to each other’s needs.
Recovery Programs
Sobriety houses help you understand the importance of life without substance dependence. You must attend regular young adult alcohol rehabilitation meetings like Narcotics or Alcoholics Anonymous. You have the chance to live a normal schedule for work, meals, leisure and sleep and this can sometimes take time to get used to. Your progress will not be hurried as each day will be filled with help and understanding.
Family and Friends
A sobriety home allows the residents to get to know their families and friends all over again. This means establishing new contacts and getting away from the old ones. It is the chance to be around people who exhibit a positive influence in your life. This helps you ease back into society without a lot of pressure or expectations.
Charles has recently published the agenda for GoingNative 2012 –the first C++ only event done in MS in many years.
Great speakers and compelling topics. Take a look here.