One of the more fascinating things that happen to us in adulthood is the emerging feeling of nostalgia. We think about the TV shows we watched, the games we played and the places we visited. Even if you didn’t care much for something at the time, the memories are nonetheless enjoyable.
And, when you reach a certain age, you might find yourself wanting to revisit the technology that was such a part of your life. Yes, suddenly you pine for the days of the VCR or that ancient Commodore 64.
As silly as it may seem, many of us just love these old hunks of junk. The design community especially holds them in high esteem, as you’ll see from the excellent code snippets below.
The Web Designer Toolbox Unlimited Downloads: 500,000+ Web Templates, Themes, Plugins & Design Assets
The Original All-In-One
These days, computer manufacturers love to tout their all-in-one systems. But back in the day, everything was that way (albeit in a massive, immovable package). This example pays homage to those old computers in 3D. Just use the included sliders to rotate your view.
Distorted Playback
Before the DVR came in with its crystal-clear HD playback, there was the humble VCR. Depending on your home entertainment setup, you could record your favorite show after performing approximately 10 agonizing steps. When it was time to watch, you were then treated to playback that featured jagged horizontal lines – just like the ones in this snippet.
A Gaming Icon Becomes an Icon
The Nintendo Gameboy may seem a little quaint when compared with the likes of the Switch. But it revolutionized portable gaming. Take as many mini-cartridges with you as you like (and a few boxes of batteries) and play all the way to Grandma’s. The beautiful irony of this example is that the system is reimagined as an iOS app icon – the new portable wonder.
May I Have This Breakdance?
In the olden days, we wanted everyone to hear our music. The boombox was the perfect way to make it happen. It was portable (even if a bit heavy) and was incredibly loud. To relive the experience, hit the play button on this snippet and get down to some fresh beats.
It’s a Phone – For Your Car!
It’s a safe bet that we take our smartphones for granted. Yet, even the cheapest ones can do things we never imagined back in the 1990s. Take, for example, this gigantic monstrosity that passed for high-tech. There was no texting, no screen – it was just meant for voice communication. Even if you’ve never seen one in person, this snippet lets you explore the device in eye-popping 3D.
I Made You a Mixtape
The original Sony Walkman took the big, bulky cassette player and put it in your pocket (you just need really big pockets). This piece of tech history brought the concept of a “personal” music player mainstream. Here, you can explore an interactive facsimile with working buttons and even a removable cassette.
When Your TV Was Also Your Monitor
In the early days of home computing, televisions often pulled double-duty as monitors. Of course, the potential for screen burn-in meant that you might forever be reminded of how bad an idea this was. This fun example shows off a Commodore 64 error screen, complete with retro TV set.
Meet Me at the Arcade (and Bring Lots of Money)
Some of the best old school tech never made it into most homes. But the arcade was one place you were sure to find the best graphics and sound of the day. The full-sized games, like this incredible 3D Pacman machine, were large enough to house all the necessary equipment. No wonder it was so popular.
How the Old Inspired the New
It’s no surprise that much of this technology still holds an influence. For the web design community, it’s less about the hardware and software advancements – although they are certainly of great importance.
The real influence can be found in the areas of UI and UX. For many of us, these devices were our first taste of interacting with a screen. Gaming machines, for example, needed to have a dead-simple UI and be intuitive enough that anyone could play.
On the other hand, clunky interfaces (like that of the VCR) were lessons in frustration. Thinking about the less-than-ideal ways to perform various tasks help us to more fully appreciate the technology that made things easier.
Overall, the items above were not only fun, they have also inspired us to create a better user experience. It’s almost like they were preparing us for this career path all along.
This software is still in development, so we don’t recommend you run it on a production site. Consider setting up a test site to play with the new version.
There are two ways to test the WordPress 5.1 beta: try the WordPress Beta Testerplugin (you’ll want to select the “bleeding edge nightlies” option), or you can download the beta here (zip).
WordPress 5.1 is slated for release on February 21, and we need your help to get there!
Site Health Check
One of the features originally slated for WordPress 5.1—the PHP error protection handler—will target WordPress 5.2 instead. Some potential security issues were discovered in the implementation: rather than risk releasing insecure code, the team decided to pull it out of WordPress 5.1. The work in #46130 is showing good progress towards addressing the security concerns, if you’d like to follow development progress on this feature.
Additional Changes
A handful of smaller bugs have also been fixed in this release, including:
TinyMCE has been upgraded to version 4.9.2 (#46094).
The block editor has had a couple of bugs fixed (#46137).
A few differences in behaviour between the classic block and the classic editor have been fixed (#46062, #46071, #46085).
When adding rel attributes to links, ensure the value isn’t empty (#45352), and that it works as expected with customizer changesets (#45292).
Developer Notes
WordPress 5.1 has many changes aimed at polishing the developer experience. To keep you informed, we publish developers’ notes on the Make WordPress Core blog throughout the release cycle. Subscribe to the Make WordPress Core blog for updates over the coming weeks, detailing other changes in 5.1 that you should be aware of.
If you think you’ve found a bug, you can post to the Alpha/Beta area in the support forums. We’d love to hear from you! If you’re comfortable writing a reproducible bug report, file one on WordPress Trac, where you can also find a list of known bugs.
In just a few weeks WordPress Five-One will be here. Your testing helps us!
Ketting is an attempt at making a generic Hypermedia API client for
javascript. It uses a ‘link’ and following links as the most important
primitive.
Last week I released version 2.5.0 on NPM so maybe it’s time to list
some of the improvements since the last update in order from most to
least interesting.
JSON:API support
JSON:API is a standard for making JSON-based APIs, and it has some
support for hypermedia ideas as well.
In particular, the standard has a links object, and it also defines
a relationship between collections and members of collections.
This release now ships with a ‘representor’ for JSON API, which means
you can now do something like this:
constmyResource=awaithome.follow('next')// This might be a html5 document.follow('author')// This might be a HAL document.follow('about')// This might be a JSON:API document
All of these will now be seamless regardless of which format any of these
hops used, only when you get() and put() the format is relevant again.
A lot of help in getting this right came from JSON:API community members such
as Gabe Sullice and Ethan Resnick. If you’re interested in the full discussion
about how JSON:API maps to HATEOAS read the Github issue.
go() function
Not every endpoint will have every appropriate link to another resource.
Sometimes you just have to work with what you have, and fetch a resource
yourself.
The go() function is a function that exists on a resource and simply
gives you a new resource based on the url you passed. The url can be relative
and will be resolved based on the ‘current’ resource.
constanotherResource=resource.go('?q=hello');
Resource is generic
If you use typescript with this package, it might be desirable to have some
typing.
Adding good support for this will be an ongoing process, but as a first step
the Resource class is now generic.
This means that you can define a function such as:
functionfoo():Resource<MyBodyType>{// ...}
Typescript will then use MyBodyType as the type that will be returned from
get() and refresh() and will demand that the value passed to put() has
this type.
By default this is any.
I think this is a decent first step, but I also imagine this will have to
continue to evolve.
esModuleInterop is false
The Typescript build now has esModuleInterop off. Apparently keeping it
set to true caused anyone who uses the library and has this setting set
to false to get errors.
So in order to not force people to change this setting, esModuleInterop is
now off, which means the library will work regardless of your own preference.
There are a lot of benefits to being a freelance web designer. Getting to work the way you want and where you want, for instance. But there are also some serious downsides to consider.
The truth is that freelancing isn’t for everyone. Aside from the freedoms that come along with going it alone, you also get a healthy dose of risk, along with our own fears, as well. It’s unavoidable and must be accepted as part of the job description.
Today, we’re going to look at some of the real risks and associated fears of being a freelancer. But don’t worry – we’re not trying to scare you!
If you’ve thought about taking the plunge and starting your own business, it’s best to know what you’re getting into. And, even if you have been in business for a while, there may be some things you haven’t really thought about.
We’ll not only explain these items, but provide you with some helpful advice on navigating them as well. Let’s get started!
Running Out of Money
This may well be the scariest part of being in business. Financial struggles can have a major impact on both your business and life.
Of course, everyone’s goal is to (at least) make a decent living. And quite often it’s a realistic one. However, there will always be ups and downs.
There may be times when you will struggle to pay the bills. Plus, depending on where you live, taxes can only add to your burden.
One way to look at this is that you’ll usually make what you earn, save for the occasional non-paying client. Therefore, staying busy is one of the best defenses against going broke. So, aim to keep that calendar full of projects.
Planning also can mitigate some of your risk. For example, putting aside some extra money in good times will provide you with some fallback resources – just in case.
Not Knowing What to Do
We’d all love to have a team of super-smart developers working for us. But the reality for most freelancers is that we have to take care of things ourselves. With that comes the risk of being asked to do something you’ve never done before.
Depending on your personality, this kind of thing might keep you awake at night (it still does for yours truly). The fear is that you won’t be able to deliver what a project requires. The potential result is upsetting your client and leaving you feeling embarrassed.
Again, it comes down to perspective. Instead of stressing, you might choose to look at this as a real opportunity to learn something new. Learning, after all, is an essential part of staying on top of your game.
Sometimes, we tend to think of learning in terms of a more formal educational setting. But we can learn just as much, if not more, through actual experience. And there’s nothing quite like knowing that you have to learn something to get you motivated.
The bottom line: Don’t be afraid of what you don’t know.
Having No One Else to Rely On
As the one-and-only boss, you get to call the shots. And you’re also responsible for virtually every part of your business. It’s a lot of weight on your shoulders (no matter how much you work out).
This is actually part of being a freelancer, though. The job requires a certain degree of self-reliance to be successful over the long term. Still, it can feel awfully lonely when you’re drowning in work or stuck on a complex problem. “Overwhelming” might be the best term to describe it.
There are some things you can do to lighten the load, however. If your financial situation is solid, you could hire on another freelancer to help. Even if it’s just to tackle a single issue you’re facing, that can provide a big boost to your mental health.
Another way to get some peace of mind is to connect with the web design community via a meetup or social media. There are undoubtedly others out there who are experiencing the very same types of challenges. Just communicating with someone who can empathize with your situation can make a positive difference.
Dealing with Clients
The day-to-day life of a web designer often includes dealing with clients on some level. Whether that be through meetings, phone or email conversations, some basic people skills are a valuable asset.
Even if you’re very outgoing, client relations can be stressful. If you’re more introverted, the whole thing can sap you of energy. It’s really the most delicate responsibility of freelancing, as you need to learn how to manage the various personalities you’ll encounter.
Just keep in mind that you don’t have to be perfect. You don’t need to come up with witty things to say or specialize in small talk. As long as you’re polite, helpful and courteous, you’ll be on your way to building solid relationships.
Even if this scares you to death, you can still learn and improve. The more practice you get, the better you can deal with it.
Professional Risk-Taker
Indeed, a big part of being in business is taking risks and conquering fears. Even the act of starting a business itself is risky – especially if you’re leaving another job to venture off on your own. But these kinds of uncertainties shouldn’t stop you from being yourself and doing what you love.
The key in all of this is in managing your expectations and learning from your experiences. We all make mistakes. Sometimes, they can be pretty big ones. And there is always a chance that we’ll be stuck in a spot where we don’t exactly know what we’re doing.
This is all part of the process. And it’s even okay to be scared, as long as you use it as motivation to keep improving.
409 Conflict is used in cases where the HTTP request was valid, but the
current state of the server prevents it from being executed.
This is usefor for API’s. A few hypothetical examples:
A user wants to add a file to a folder, but the folder doesn’t exist yet.
Amazon S3 uses it when you try to delete a bucket that’s not empty.
You’re creating a new blog post, but it refers to a category that was
deleted.
The key here is that it might be possible to run the same request again after
this conflict is resolved, by for example:
Creating the folder you’re trying to upload to.
Removing all items from the S3 bucket before removing it.
Re-creating or undeleting the category you’re trying to assign to the blog
post.
The HTTP specification recommends that the HTTP response body contains
information in the response body that the client or user can use to resolve
the conflict.
Example
HTTP/1.1409ConflictContent-Type:text/plain
You tried to upload a file to a folder that doesn't exist. Create the folder
and try again!
Usage
If you are building an API, it’s a good idea to emit 409 conflict for these
situations. It can be seen as a more specific code than 400 and somtimes 409.
You might even be able to define a response body that a client can use to
automatically resolve the conflict, or at least inform the user in a standard
way what was wrong.
