r/web_design - [HELP] Ux/Ui to handle zoom, pan, and click events on Html canvas (Image)
Strategy

[HELP] Ux/Ui to handle zoom, pan, and click events on Html c…


I am developing a coloring book app, (attached screenshot). I have this UI state implemented currently,

  1. Initially, bucket fill is enabled and the user can click on the image to fill the image on the canvas.

  2. To zoom in /out, pan, the user needs to drag the input slider, it enables zoom mode and panning of the image (at the same time disables any click event like fill/brush)

  3. To start painting/filling (ie enabling drawing mode) the user has to click on either bucket/brush icon again.

  4. It’s quite confusing from the user perspective once in pan zoom mode clicking on anywhere will not perform any action until bucket/brush icons are clicked (to enter drawing mode again)

I am all confused about how to handle this scenario in a more effective way.

r/web_design - [HELP] Ux/Ui to handle zoom, pan, and click events on Html canvas (Image)



Source link

r/webdev - Wanna learn how to deploy production grade Django+ ReactJs apps?
Strategy

Wanna learn how to deploy production grade Django+ ReactJs a…


Hey Community,

I am planning to write a detailed guide on how to deploy production grade Django app. To teach this I plan to show my own job board which I recently open sourced https://github.com/TrakBit/fullstackbot-backend. I plan to teach how to deploy :

r/webdev - Wanna learn how to deploy production grade Django+ ReactJs apps?

It is aimed at teaching to deploy for real world and not just side hobby projects. Thus want to teach a way by which its cost effective to run, scalable, and also super easy to push new code by linking to your Github repo.

I have made several commercial and open source project using Django which you can check here: https://github.com/TrakBit/.

if you are interested in such guide sign up here https://harshvardhan.carrd.co/



Source link

Why React Native Can Reduce Your Development Costs
Strategy

Why React Native Can Reduce Your Development Costs


Nowadays, the mobile app industry is consistently stealing the show. So if you want to take over the market, app presence on all platforms is a must. Building a native app for each platform is a costly and time-consuming approach; this is where cross-platform development comes in handy. And React Native is one of those cross-platform solutions. According to the 2020 developer survey by Statista, React Native is the most common cross-platform application framework used by global developers.

And there are excellent reasons for that. React Native offers high performance, cost-efficiency, and faster time-to-market. And the list goes on. In this article, we’ll go through the critical cost-saving benefits of using React Native, and you’ll be convinced of the cost-effectiveness of React Native.

Top 7 Factors That Influence App Development Cost

Before we dive into information on how React Native reduces the cost of development, let’s first consider the main factors that influence app development cost:

  • Type of app development. The most crucial factor influencing your app development cost is the type of app you choose to develop, i.e. native or cross-platform. Using cross-platform development allows you to reduce costs and save engineering time, as you use the same code across both platforms. The native approach can be more costly, as you’d need to design and develop software for each platform separately.
  • App platform. Do you want to create an iOS app, an Android app, or both? Each platform involves different programming languages and various development tools. Moreover, the user experience design of iOS apps varies significantly from Android apps. Determining on which platform your mobile solution will run can help predict development time, size of the team, and, therefore, cost.
  • The complexity of functions and features. The required app features and the complexity of their implementation have a substantial impact on mobile app development costs. For example, if your software has essential functionality like a calculator, it’ll require much less investment and development time. Suppose you’re going to build a large mobile app that contains complex functionality (an immense database, AR/VR features, different integrations, etc.). In that case, you’ll need a bigger team, much more time, and it’ll cost way more to develop such a solution.
  • UI/UX design. Design is an integral part of any mobile app’s development. The cost of your app development may depend on very detailed design specifications. For example, when considering your app user interface, you can choose a native design that contains iOS- and Android-ready templates. This design approach is faster and more cost-effective. Another option is custom design that implies unique architecture for each UI element. In this case, it’ll require more time for designing and prove far more costly.
  • Specific backend. If you want your software to contain features like user accounts or an opportunity to upload images, you’ll need backend development. The backend stores and arranges data and ensures the app on the client-side runs properly. So, your app development costs may significantly depend on the number of variables involved in the backend.
  • Third-party app integrations. If you want to add extra features from other sources, it can drive up app development costs. For example, adding GPS integration, social login, or payment integration, such as Apple Pay, may significantly increase the total cost of app development.
  • App testing. At every stage of development, you should verify that software runs properly and has no bugs and vulnerabilities. To minimize issues and ensure the app’s quality, you need QA engineers. The size of your QA team directly depends on your app’s size.

Now that we know what may influence our app development costs, we can consider how React Native can reduce the cost of mobile app development.

React Native Cost Reduction Benefits

Let’s look at the most convincing reasons to use React Native to develop your next mobile app and see how this framework can significantly reduce your development costs.

Reusable Code and Components

Using React Native, there is no need to develop separate mobile apps for each platform. Reusable code and components are probably the most significant advantage of how React Native reduces costs. This framework allows developers to write code once and share 90-99% of that code between iOS and Android platforms without any technical flaws or glitches.

Reduction in Time and Development Costs

Thanks to reusable code and ready-made components, you can cut the production time and cost in half. Using React Native, developers can easily maintain the same code base between different platforms.

Lower Maintenance Costs

Native apps require regular updates for each mobile device separately. Using React Native, you only have to deal with a single code base; therefore, you can fix bugs more easily. As a result, React Native reduces app development costs and makes maintenance more straightforward.

Lots of Ready-Made Solutions and Libraries

One of the great benefits that reduces the cost of developing React Native apps is its community. Since React Native enjoys enormous popularity among developers, there are many publicly available, ready-made solutions and libraries that allow teams to meet challenges faster. For example, suppose you want your mobile solution to contain social media features, such as a social share button or the ability to send data to social networks. To quickly implement this feature, you can use the react-native-share library.

Great Customer Experience

None of us likes to wait for an app to load. High performance is one more obvious way React Native can cut your development costs. This is because the React Native framework uses native UI elements, and it’s compiled into a native app. As a result, you get a faster and more competitive mobile app that offers an instantaneous loading experience.

Lower UI Cost

React Native allows designers to bring uniformity and a fully optimized UI that works perfectly on numerous devices. This leads to more responsive user interfaces, a smoother feel, and a superb user experience. Therefore, React Native cuts design time and costs by optimizing one mobile app for multiple platforms.

Seamless Integration

Everyone needs a customer-centric app with all-inclusive features. With React Native, you can do just that with minimum effort and cost. Developers need to connect a native or third-party module to the appropriate plugin. You can consider the most well-known React Native third-party plugins such as React Native Router Flux, React Native Modalbox, or  React Native Selectme.

Famous Apps Built With React Native

Nowadays, the biggest companies worldwide recognize React Native’s advantage and potential for business. Let’s look at some well-known projects made with React Native and see why this framework is suitable for mobile app development.

Instagram

Instagram is probably the most popular mobile app globally, with over 1 billion monthly active users. By choosing React Native, Instagram developers managed to substantially improve their velocity and deliver the product much faster, due to the opportunity to share 85-99% of their code between the apps for both Android and iOS mobile devices.

Airbnb

Airbnb is a famous American vacation rental online marketplace. Initially, the company’s goal was to accelerate the development time and quickly penetrate the market. They needed technology that helped them reach that goal. React Native was their choice, and, as a result, they got the famous app out in a short time with a native-like experience. Now Airbnb has 43.3 million users in the United States.

Bloomberg

Bloomberg is a popular mobile application for iOS and Android that provides global business and finance news. The company chose React Native to accelerate the release of new product features and provide users with a streamlined, interactive experience on all platforms.

Facebook Ads

Facebook, which released React Native in 2015, made using this technology a must for the company. Thus, they made their other product, Facebook Ads, using the React Native framework and achieved excellent results. Today, Facebook Ads is a quickly responsive app with clean UI and intuitive UX on both platforms.

UberEats

UberEats is a popular food ordering and delivery app. Initially, the company needed to enhance its built-in restaurant dashboard, and, for this purpose, they chose React Native. The developers were pleasantly surprised by their experience with the framework. Today, their updated restaurant dashboard allows them to attract more clients and significantly increase their consumer base.

Our Experience With React Native

Our client, Fractal Labs, came up with the idea of a self-service platform for financial partners targeting SMEs. The concept was meant to enable financial services to access valuable customer data, enhance risk models, lower loss-ratio through continuous monitoring, engage untapped customers, and intelligently target products.

Fractal Labs was looking for a partner that could help them build a mobile application that serves as a front-end interface for their backend-heavy open banking API.

Our TechMagic team was responsible for building a mobile app and its fast release for both iOS and Android platforms. We chose React Native as a solution, since it accelerates development time by sharing 90-99% of our code between iOS and Android platforms.

As a result, after a few months, we released a properly operating React Native app that feels and looks native on all devices. What’s more, we managed to reach excellent app performance quality, involve only one engineer, and save 45% on our budget.

Final Thoughts

As you can see, React Native can cut costs for many reasons. This framework allows you to build your mobile solution in a more straightforward and faster way, with minimum cost and time commitments. What is more, it does all of this without sacrificing on the quality of the application. 



Source link

Learn How to Create a Messaging App in 2021
Strategy

Learn How to Create a Messaging App in 2021


Look around and tell me what you see; you may find people with smartphones in their hands. What are they doing? Most likely, they are texting. Indeed, messaging has become a modern way of communicating.

If you have a concept of a new chat app for the mass-market or want to get messaging software for your organization, here are some facts and insights on how to create a messaging app.

Is it a Good Idea to Create a Chat App in 2021?

Let’s take a test. Open the app list on your smartphone and check out how many messaging applications you have. Probably, there are more than five of them and dozens of websites you daily visit also have chat support. Pretty impressive, isn’t it? Search the market, and you will find millions of chat apps with active users. Every day the list is updated with new messaging apps. In fact, some surveys and numbers prove, messaging has a huge role in your lives.

To prove the role of chat apps in our daily routine, check out some interesting statistics below:

  • The State of Mobile Internet Connectivity Report 2020 by GSMS states 3,8 billion people are using mobile internet. It is almost half of the population. The number of users increases by 250 million each year.
  • According to Statista, already 6,95 billion people use mobile phones worldwide. By the end of 2021, the number will hit the point of 7,1 billion.
  • The top 3 messaging apps are WhatsApp, Facebook Messenger, and WeChat. Together they have over 4 billion active users worldwide.
  • Another statistic shows that WhatsApp is delivering about 100 billion messages daily.

And, a few more short stats:

  • Over 2,52 billion people are using chat apps. By 2022, the number will reach 3 billion.
  • Over 41 million messages are being sent every minute.
  • 20 billion business messages are sent through mobile apps each month.
  • 5 billion emojis are sent daily.

It is a general and brief survey of years of investigations and statistics. Still, they once again prove the world of messaging is full of opportunities.

Marketing Survey and Platforms

If you had to choose between the phone call and a message, what would you choose? When we look at the phone call, we always wonder whether there was no option to write instead of calling. Yes, this is the new normal. People got used to replacing phone calls and even real conversations with messages. Why not? Isn’t it more comfortable and faster? After all, our life is too busy to be on the phone. Besides being convenient, messengers bring billions of dollars through active users. The statistics show that net income and numbers are increasing every year.

In 2020, research by the Wall Street Journal published data about the average revenue of each user through messaging apps. Thus, each WeChat user generates $7, $4 for each WhatsApp user, and $5 for a Facebook user. But, let’s deep dive into the numbers and learn the multi-million dollar turnover that is happening around us every day.

Facebook apps, including WhatsApp, have more than 3 billion monthly active users. For the first quarter of 2020, the company reported over $17,7 billion in revenue. Every year, the revenue gets 17% registered growth.

According to statistics, WhatsApp is still considered the most popular messaging app. If there was a country called WhatsApp, it would have 1.5 billion people and an economy of over $5 billion. 

With 1,15 billion monthly active users, WeChat has over $12,7 million in revenue. 20 million Chinese companies are using WeChat for business as an integral part of daily business processes. 

Platforms for Chat Apps. The Web Platform, Android and iOS

First, we had computers, and then we started using smartphones that almost replaced computers. Today, we use apps on smartphones, and we can use the same apps on computers. Life will never stop surprising us.

Cross-platform app development is a common practice. A single app can be created to be available on different platforms or individually for each platform. Each of the platforms has its programming language. Outsourcing app development may solve the task for both cross-platform and native app developments. 

Challenges of Building a Chat App

Along with the growing popularity of mobile apps, user requests also increased. They demand a faster connection, new cool features, and better security. Those are the challenges developers face when building a chat app.

With a calculation of potential risks and possible issues, a professional development team will be able to deal with them on time.

Real-Time Features

The functionality of the chat app depends on its real-time features. They should be up-to-date and smooth operating. Here is a shortlist of must-have features:

  • Instant messaging.
  • Custom fonts and stickers.
  • The function to mute chat.
  • Status for each message (sent, received, seen).
  • Voice and video calls.
  • The feature to attach documents and images, send voice and video messages.

Security Issues

When downloading a new app, we think twice about giving permission. Indeed, security is the major concern of choosing a chat app and a challenge for developers. The new messaging app should have a reliable and attractive interface. But, it should also prove to have data protection. Here are top security features that are a must:

  • Reliable end-to-end encryption protocols.
  • Secure data storage.
  • Extra protection features like cryptographic keys.
  • Privacy policy agreement before using the app.

Server Overload

The growing number of users is a plus, but it may also cause server overload. To provide stable and smooth functionality, the app server capacity should be scalable. Thus, the chat app will have a stable performance for peak workload periods.

Constant Updates

Users do love updates and new features. It is an option to keep the app functional and up-to-date. The updates allow us to fix current bugs and, of course, keep connected with users. The most important thing about frequent updates is protecting existing data.

How Much Does it Cost to Develop a Messaging App Like WhatsApp?

An application that brings billions of dollars might be worth a lot to develop. Sill, after all, when it all started, nobody knew about WhatsApp, and it was a mobile app in the app store. 

Are you thinking about how to create a messaging app like WhatsApp and wondering how much it may cost? Before getting to pricing, it is worth understanding how the price is formed.

Since 2013, the prices for developing chat apps have increased by three times. Today, the price for a similar messaging app may cost about $50,000. Undoubtedly, this is a high price, but with market surveys and the growing popularity of similar apps, it is worth investing in a chat app.

Most chat apps have standard functions like instant messages, photo and location sharing, audio, and video calls. Each new feature adds popularity to the chat app and, correspondingly, increases the price.

The process of app development should be structured and planned in detail. The road map for the implementation of app development may be complex, but the key steps are as follows:

  • It should always start with a basic idea of the chat app.
  • The next step decides who will be in charge of creating a messaging app. A popular option is outsourcing mobile app development. 
  • Software development may start from $30,000 for one platform. The price may increase with every new feature. It is important to set a budget and understand needs before proceeding. Thus, the result will be as close to the preliminary plan as possible. 

If you are interested in the technologies of developing messaging software, check out the complete guide on how to create a messaging app.



Source link

r/graphic_design - How to vectorize from a Procreate image
Strategy

How to vectorize from a Procreate image : graphic_design


I am a beginning graphic designer with experience in Procreate (iPad). I created a horse drawing for a client who then requested a vector format. I have tried following tutorials using Ai, Capture, Vectornator, etc., but the final vector always shows something similar as seen in the screengrab. Either there are white holes between colors or brown bleeds onto the other colors. I am not trained enough to know what is causing this. Any advice would be appreciated! Is it something with the original Procreate drawing (.png format)? Or some setting in Ai/Capture?

r/graphic_design - How to vectorize from a Procreate image



Source link

Deploying a Simple Golang Web App on Heroku
Strategy

Deploying a Simple Golang Web App on Heroku


The Go programming language, often referred to as “Golang,” has gained a lot of well-deserved traction in the DevOps community. Many of the most popular tools such as Docker, Kubernetes, and Terraform are written in Go, but it can also be a great choice for building web applications and APIs. 

Go provides you with all the speed and performance of a compiled language, but feels like coding in an interpreted language. This comes down to the great tooling that you get out of the box with a compiler, runner, test suite, and code formatter provided by default. Add to that the robust and easily comprehensible approach to concurrency, to take maximum advantage of today’s multi-core or multi-CPU execution environments, and it’s clear why the Go community has grown so rapidly.

Go feels like it was created with specific goals in mind, leading to a deceptively simple language design that’s straightforward to learn, without compromising on capabilities.

In this post, I’m going to show you how easy it is to develop a simple web application in Go, package it as a lightweight Docker image, and deploy it to Heroku. I’ll also show a fairly new feature of Go: built-in package management.

Go Modules

I’m going to use Go’s built-in module support for this article.

Go 1.0 was released in March 2012. Up until version 1.11 (released in August 2018), developing Go applications involved managing a GOPATH for each “workspace,” analogous to Java’s JAVA_HOME, and all of your Go source code and any third-party libraries were stored below the GOPATH.

I always found this a bit off-putting, compared to developing code in languages like Ruby or JavaScript where I could have a simpler directory structure isolating each project. In both of those languages, a single file (Gemfile for Ruby, package.json for JavaScript) lists all the external libraries, and the package manager keeps track of managing and installing dependencies for me.

I’m not saying you can’t manage the GOPATH environment variable to isolate projects from one another. I particularly find the package manager approach is easier.

Thankfully, Go now has excellent package management built in, so this is no longer a problem. However, you might find GOPATH mentioned in many older blog posts and articles, which can be a little confusing.

Hello, World!

Let’s get started on our web application. As usual, this is going to be a very simple “Hello, World!” app, because I want to focus on the development and deployment process, and keep this article to a reasonable length.

Pre-requisites

You’ll need:

Go mod init

To create our new project, we need to create a directory for it, and use the go mod init command to initialize it as a Go module.

It’s common practice to use your GitHub username to keep your project names globally unique, and avoid name conflicts with any of your project dependencies, but you can use any name you like.

You’ll see a go.mod file in the directory now. This is where Go will track any project dependencies. If you look at the contents of the file, they should look something like this:

Let’s start committing our changes:

Gin

We’re going to use Gin for our web application. Gin is a lightweight web framework, similar to Sinatra for Ruby, Express.js for Javascript, or Flask for Python.

Create a file called hello.go containing this code:

Let’s break this down a little:

This creates a router object, r, using the built-in defaults that come with Gin.

Then, we assign a handler function to be called for any HTTP GET requests to the path /hello, and to return the string “Hello, World!” and a 200 (HTTP OK) status code:

Finally, we start our web server and tell it to listen on port 3000:

To run this code, execute:

You should see output like this:

Now if you visit http://localhost:3000/hello in your web browser, you should see the message “Hello, World!”

Notice that we didn’t have to install Gin separately, or even edit our go.mod file to declare it as a dependency. Go figures that out and makes the necessary changes for us, which is what’s happening when we see these lines in the output:

If you look at the go.mod file, you’ll see it now contains this:

You will also see a go.sum file now. This is a text file containing references to the specific versions of all the package dependencies, and their dependencies, along with a cryptographic hash of the contents of that version of the relevant module.

The go.sum file serves a similar function to package-lock.json for a JavaScript project, or Gemfile.lock in a Ruby project, and you should always check it into version control along with your source code.

Let’s do that now:

Serving HTML and JSON

I’m not going very far into what you can build with Gin, but I do want to demonstrate a little more of its functionality. In particular, sending JSON responses and serving static files.

Let’s look at JSON responses first. Add the following code to your hello.go file, right after the r.GET block:

Here we’re creating a “group” of routes behind the path /api with a single path /ping which will return a JSON response.

With this code in place, run the server with go run and then hit the new API endpoint:

You should get the response:

Finally, let’s make our web server serve static files. Gin has an additional library for this.

Change the import block at the top of the hello.go file to this:

The most popular code editors have Golang support packages you can install which will take care of the import declarations for you automatically, updating them for you whenever you use a new module in your code.

Then, add this line inside the main function:

The full code for our web application now looks like this:

hello.go

The r.Use(static.Serve... line enables our web server to serve any static files from the views directory, so let’s add a few:

views/css/stylesheet.css

views/index.html

Now restart the web server using go run hello.go and visit http://localhost:3000 and you should see the styled message:


Dockerize

We’ve written our Go web application, now let’s package it up as a Docker image. We could create it as a Heroku buildpack, but one of the nice features of Go is that you can distribute your software as a single binary file. This is an area where Go really shines, and using a Docker-based Heroku deployment lets us take advantage of that. Also, this technique isn’t limited to Go applications: you can use Docker-based deployment to Heroku for projects in any language. So, it’s a good technique to understand.

So far, we’ve been running our code with the go run command. To compile it into a single, executable binary, we simply run:

This will compile all our Go source code and create a single file. By default, the output file will be named according to the module name, so in our case it will be called helloworld.

We can run this:

And we can hit the same HTTP endpoints as before, either with curl or our web browser.

The static files are not compiled into the binary, so if you put the helloworld file in a different directory, it will not find the views directory to serve our HTML and CSS content.

That’s all we need to do to create a binary for whatever platform we’re developing on (in my case, my Mac laptop). However, to run inside a Docker container (for eventual deployment to Heroku) we need to compile a binary for whatever architecture our Docker container will run on.

I’m going to use Alpine Linux, so let’s build our binary on that OS. Create a Dockerfile with the following content:

In this image, we start with the golang base image, add our source code, and run go build to create our helloworld binary.

We can build our Docker image like this:

Don’t forget the trailing . at the end of that command. It tells Docker we want to use the current directory as the build context.

This creates a Docker image with our helloworld binary in it, but it also contains all the Go tools needed to compile our code, and we don’t want any of that in our final image for deployment, because it makes the image unnecessarily large. It can also be a security risk to install unnecessary executables on your Docker images.

We can see the size of our Docker image like this:

For comparison, the alpine image (a lightweight Linux distribution, often used as a base for Docker images) is much smaller:

On my Mac, the helloworld binary is around 14MB, so the Golang image is much bigger than it needs to be.

What we want to do is use this Dockerfile to build our helloworld binary to run on Alpine Linux, then copy the compiled binary into an Alpine base image, without all the extra Golang tools.

We can do this using a “multistage” Docker build. Change the Dockerfile to look like this:

On the first line, we label our initial Docker image AS builder.

Later, we switch to a different base image FROM alpine and then copy the helloworld binary from our builder image like this:

Build the new Docker image:

Now, it’s the size you would expect for a base Alpine image plus our helloworld binary:

We can run our web server from the Docker image like this. (If you have another version running using go run hello.go or ./helloworld, you’ll need to stop that one first, to free up port 3000.)

docker run --rm -p 3000:3000 helloworld

The dockerized webserver should behave just like the go run hello.go and ./helloworld versions except that it has its own copies of the static files. So, if you change any of the files in views/ you won’t see the changes until you rebuild the Docker image and restart the container.

Deploy to Heroku

Now that we have our dockerized web application, let’s deploy it to Heroku. Heroku is a PaaS provider that makes it simple to deploy and host an application. You can set up and deploy your application through the Heroku UI, or through the Heroku CLI. For this example, we’ll use the Heroku command-line application.

Getting PORT From an Environment Variable

We’ve hard-coded our web server to run on port 3000, but that won’t work on Heroku. Instead, we need to alter it to run on whichever port number is specified in the PORT environment variable, which Heroku will supply automatically.

To do this, alter the r.Run line near the bottom of our hello.go file, and remove the ":3000" string value so the line becomes:

The default behavior of Gin is to run on whatever port is in the PORT environment variable (or port 8080 if nothing is specified). This is exactly the behavior Heroku needs.

Setting up Our Heroku app

First, log into Heroku:

Now, create an app:

Tell Heroku we want to build this project using a Dockerfile, rather than a buildpack:

To do this, we also need to create a heroku.yml file like this:

The heroku.yml file is a manifest that defines our app and allows us to specify add-ons and config vars to use during app provisioning. 

Next, add git and commit these files, then push to Heroku to deploy:

My git configuration uses main as the default branch. If your default branch is called master, then run git push heroku master instead.

You should see Heroku building the image from your Dockerfile, and pushing it to the Heroku Docker registry. Once the command completes, you can view the deployed application in your browser by running:

Conclusion

To recap, here’s a summary of what we covered today:

  • Creating a Golang web application, using Go modules and the Gin web framework to serve strings, JSON, and static files.
  • Using a multistage Dockerfile to create a lightweight Docker image.
  • Deploying a Docker-based application to Heroku using heroku stack:set container and a heroku.yml file.

I’ve only scratched the surface in this article on how to use Go to build web applications and APIs. I hope this gives you enough to get started on your own Golang web applications.



Source link

r/graphic_design - Logo Designs
Strategy

Logo Designs : graphic_design


Hey! I’m rebranding the business I launched in a panic last year. I cant afford a graphic designer and I’ve never done this kind of work (I’m using photoshop and illustrator (and youtube). I’m sure I have a lot to learn. I’m not afraid of critique, I’d love to hear it!!

For sake of time (and ease) I downloaded some templates off creative market, because starting from a blank page was not working.

Brand Identity: I have a wellness business that focuses on redefining self care; away from a commodity driven practice and toward a practice of deepening self awareness through heart based, energetic practices. I use tools like astrology and tarot and I was trying to bring those elements into this design.

The heart is designed to look like its expanding, the border/layout is meant to evoke a playing card/tarot card kind of feeling.

As I said above, any advice is welcome, or a vote on your favorite would be so helpful. I’m not super attached to any of the designs, but I like the direction it is heading (away from a blank page 😉

Thanks for your time!

EDIT: I know none of these are perfect, they all need to be centered and edits in the arrangement but I’m trying to decide which idea to move forward with, and opinions on typography, overall design, placement of objects, etc.

r/graphic_design - Logo Designs



Source link

r/webdev - A FOSS, Clean and Quick Way to Learn Tables (Drilling/Flash Cards)
Strategy

A FOSS, Clean and Quick Way to Learn Tables (Drilling/Flash …


My little sister had difficulty learning multiplication tables, and we realised that drilling (asking multiple questions rapidly, and moving on quickly) was giving the fastest results. Most other websites or apps that do this are cluttered with ads, so I though I would build a clean no bullshit app that does this.

Its still a work in progress, and the settings don’t work. I was thinking of adding accounts so you can track your progress. Let me know of other suggestions. Hope you guys find it useful 🙂

App: https://www.tabill.tk

Repo: https://github.com/d4mr/tabill

r/webdev - A FOSS, Clean and Quick Way to Learn Tables (Drilling/Flash Cards)
r/webdev - A FOSS, Clean and Quick Way to Learn Tables (Drilling/Flash Cards)



Source link

Netlify Edge Handlers | CSS-Tricks
Strategy

Netlify Edge Handlers | CSS-Tricks


Netlify Edge Handlers are in Early Access (you can request it), but they are super cool and I think they are worth wrapping your brain around now. I think they change the nature of what Jamstack is and can be.

You know about CDNs. They are global. They host assets geographically close to people so that websites are faster. Netlify does this for everything. The more you can put on a CDN, the better. Jamstack promotes the concept that assets, as well as pre-rendered content, should be on a global CDN. Speed is a major benefit of that.

The mental math with Jamstack and CDNs has traditionally gone like this: I’m making tradeoffs. I’m doing more at build time, rather than at render time, because I want to be on that global CDN for the speed. But in doing so, I’m losing a bit of the dynamic power of using a server. Or, I’m still doing dynamic things, but I’m doing them at render time on the client because I have to.

That math is changing. What Edge Handlers are saying is: you don’t have to make that trade off. You can do dynamic server-y things and stay on the global CDN. Here’s an example.

  1. You have an area of your site at /blog and you’d like it to return recent blog posts which are in a cloud database somewhere. This Edge Handler only needs to run at /blog, so you configure the Edge Handler only to run at that URL.
  2. You write the code to fetch those posts in a JavaScript file and put it at: /edge-handlers/getBlogPosts.js.
  3. Now, when you build and deploy, that code will run — only at that URL — and do its job.

So what kind of JavaScript are you writing? It’s pretty focused. I’d think 95% of the time you’re outright replacing the original response. Like, maybe the HTML for /blog on your site is literally this:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Test a Netlify Edge Function</title>
</head>
<body>
  <div id="blog-posts"></div>
</body>
</html>

With an Edge Handler, it’s not particularly difficult to get that original response, make the cloud data call, and replace the guts with blog posts.

export function onRequest(event) {
  event.replaceResponse(async () => {
    // Get the original response HTML
    const originalRequest = await fetch(event.request);
    const originalBody = await originalRequest.text();

    // Get the data
    const cloudRequest = await fetch(
      `https://css-tricks.com/wp-json/wp/v2/posts`
    );
    const data = await cloudRequest.json();

    // Replace the empty div with content
    // Maybe you could use Cheerio or something for more robustness
    const manipulatedResponse = originalBody.replace(
      `<div id="blog-posts"></div>`,
      `
        <h2>
          <a href="https://css-tricks.com/${data[0].link}">${data[0].title.rendered}</a>
        </h2>
        ${data[0].excerpt.rendered}
      `
    );

    let response = new Response(manipulatedResponse, {
      headers: {
        "content-type": "text/html",
      },
      status: 200,
    });

    return response;
  });
}

(I’m hitting this site’s REST API as an example cloud data store.)

It’s a lot like a client-side fetch, except instead of manipulating the DOM after request for some data, this is happening before the response even makes it to the browser for the very first time. It’s code running on the CDN itself (“the edge”).

So, this must be slower than pre-rendered CDN content then, because it needs to make an additional network request before responding, right. Well, there is some overhead, but it’s faster than you probably think. The network request is happening on the network itself, so smokin’ fast computers on smokin’ fast networks. Likely, it’ll be a few milliseconds. They are only allowed 50ms of execution time anyway.

I was able to get this all up and running on my account that was granted access. It’s very nice that you can test them locally with:

netlify dev --trafficMesh

…which worked great both in development and deployed.

Anything you console.log() you’ll be able to set in the Netlify dashboard as well:

Here’s a repo with my functioning edge handler.



Source link

On Type Patterns and Style Guides
Strategy

On Type Patterns and Style Guides


Over the last six years or so, I’ve been using these things I’ve been calling “type patterns” in my web design work, and they’ve worked out pretty well for me. I’ll dig into what they are and how they can make their way into CSS, and maybe the idea will click with you too and help with your day-to-day typography needs.

If you’ve used print design desktop software like QuarkXPress, Adobe InDesign, or CorelDraw, then imagine this idea is an HTML/CSS translation of “paragraph styles.”

When designing a book (that spans hundreds of pages), you might want to change something about the heading typography across the whole book (on the fly). You would define how a certain piece of typography behaves in one central place to be applied across the entire project (a book, in our example). You need control of the patterns.

Most programs use this naming style, but their user interfaces vary a little.

When you pull up the pane, there’s usually a “base” paragraph style that all default text belongs to. From there, you can create as many as you want. Paragraph styles are for “block” level-like elements, and character styles are for “inline” level-like elements, such as bold or unique spans.

The user interface specifics shouldn’t matter — but you can see that there are a lot of controls to define how this text behaves visually. Under the hood, it’s just key: value pairs, which is just like CSS property: value pairs

h1 {
  font-family: "Helvetica Neue", sans-serif; 
  font-size: 20px;
  font-weight: bold;
  color: fuchsia;
}

Once defined, the styles can be applied to any piece of text. The little + (next to the paragraph style name below) in this case, means that the style definition has changed.

If you want to apply those changes to everything with that paragraph style, then you can “redefine” the style and it will apply project-wide.

When I say it like that, it might make you think: that’s what a CSS class is.

But things are a little more complicated for a website. You never know what size your website will be displayed at (it could be small, like on a mobile device, or giant, like on a desktop monitor, or even on monochrome tablet, who knows), so we need to be contextual with those classes and have then change based on their context.

Styles change as the context changes.

The bare minimum of typographic control

In your very earliest days as a developer, you may have been introduced to semantic HTML, like this:

<h1>Here's some HTML stuff. I'm a heading level 1</h1>
<p>And some more. I'm a paragraph.</p>

<h2>This is a heading level 2</h2>
<p>And some more pragraph stuff.</p>

And that pairs with CSS that targets those elements and applies styles, like this:

h1 {
  font-size: 50px; /* key: value pairs */
  color: #ff0066;
}

h2 {
  font-size: 32px;
  color: rgba(0,0,0,.8);
}

p {
  font-size: 16px;
  color: deepskyblue;
  line-height: 1.5;
}

This works!

You can write rules that target the headers and style them in descending order, so they are biggest > big > medium, and so on.

Headers also already have some styles that we accept as normal, thanks to User Agent styles (i.e. default styles applied to HTML by the browser itself). They are meant to be helpful. They add things like font-weight and margin to the headers, as well as collapsing margins. That way — without any CSS at all — we can rest assured we get at least some basic styling in place to establish a hierarchy. This is beginner-friendly, fallback-friendly… and a good thing!

As you build more complex sites, things get more complicated

You add more pages. More modules. More components. Things start to get more complex. You might start out by adding unique classes and styles for every single little thing, but it’ll catch up to you.

First, you start having classes for special situations:

<h1 class="page-title">
  Be <span class='super-ultra-magic-rainbow'>excellent</span> to each other
</h1>

<p class="special-mantra">Party on, <em>dudes</em>.</p>

<p>And yeah. I'm just a regular paragraph.</p>

Then, you start having classes everywhere (most CSS methodologies even encourage this):

<header class="site-header">
  <h1 class="page-title">
    Be <span class='ultra-magic-rainbow'>excellent</span> to each other
  </h1>
</header>

<main class="page-content">
  <section class="welcome">
    <h2 class="special-mantra">Party on <em>dudes</em></h2>

    <p class="regular-paragraph">And yeah. I'm just regular</p>
  </section>
</main>

Newcomers will try and work around the default font sizes and collapsing margins if they don’t feel confident resetting them.

This is where people start trying out margin-top: -20px… and then stuff gets whacky. As you keep writing more rules to wrangle things in, it will feel like you are “fixing” things instead of declaring how you actually want them to work. It can quickly feel like you are “fighting” the CSS cascade when you’re unaware of the browser’s User Agent styles.

A real-world example

Imagine you’re at your real job and your boss (or the visual designer) gives you this “pixel perfect” Adobe Photoshop document. There are a bunch of colors, layout, and typography.

You open up Photoshop and start to poke around, but there are so many pages and so many different type styles that you’ll need to take inventory and gather what styles can be combined or used in combination.

Would you believe that there are 12 different sizes of type on this page? There’s possibly even more if you also take the line-height into consideration.

It feels great to finish a visual layout and hand it off. However, I can’t tell you how many full days I’ve spent trying to figure out what the heck is happening in a Photoshop document. For example, sometimes small-screens aren’t taken into consideration at all; and when they are, the patterns you find aren’t always shared by each group as they change for different screen types. Some fonts start at 16px and go up to 18px, while others go up to 19px and become italic. How can spot context changes in a static mockup?

Sometimes this is with fervent purpose; other times the visual designer is just going on feel and is happy to round things up and down to create reusable patterns. You’ll have to talk to them about it. But this article is advocating that we talk about it much earlier in the process.

You might get a style guide to reference. But even that might not be specific enough to identify contexts.

Let’s zoom in on one of those guidelines:

We get more content direction than we do behavior of the content in different contexts.

You may even get a formal, but generic, style guide with no pixel sizes or notes on varying screen sizes at all!

Don’t get me wrong: this sort of thing is defintely a nice thought, and it might even be useful for others, like in some client meeting or something. But, as far as front-end development goes, it’s more confusing than helpful. I’ve received very thorough style guides that looked nice and gave lots of excellent guidelines for things like font sizes, but are completely mismatched with the accompanying Photoshop document. On the other end of the spectrum, there are style guides that have unholy amounts of specifics for every type of heading and combination you could ever imagine — and more.

It’s hard to parse this stuff, even with the best of intentions!

Early in your development career, you’d probably assume it’s your job to “figure it out” and get to work, writing down all the pixels and trying your best to make sense of it. Go getem!

But, as you start coding all the specifics, things can get a little overwhelming with the amount of duplication going on. Just look at all the repeated properties going on here:

.blog article p {
  font-family: 'Georgia', serif;
  font-size: 17px;
  line-height: 1.4;
  letter-spacing: 0.02em;
  margin-bottom: 10px;
}

.welcome .main-message {
  font-family: 'Georgia', serif;
  font-size: 17px;
  line-height: 1.4;
  letter-spacing: 0.02em;
  margin-bottom: 20px;
}

@media (min-width; 700px) {
  .welcome .main-message {
    font-size: 18px;
  }
}

.welcome .other-thing {
  font-family: 'Georgia', serif;
  font-size: 17px;
  line-height: 1.4;
  letter-spacing: 0.02em;
  margin-bottom: 20px;
}

.site-footer .link list a {
  font-family: 'Georgia', serif;
  font-size: 17px;
  line-height: 1.4;
  letter-spacing: 0.02em;
  margin-bottom: 20px;
}

You might take the common declarations and apply them to the body instead. In smaller projects, that might even be a good way to go. There are ways to use the cascade to your advantage, and others that seem to tie too many things together. Just like in an Object Oriented programming language, you don’t necessarily want everything inheriting everything.

body {
  font-family: 'Georgia', serif;
  font-size: 17px;
  line-height: 1.4;
  letter-spacing: 0.02em;
}

Things will work out OK. Most of the web was built like this. We’re just looking for something even better.

Dealing with design revisions

One day, there will be a meeting. In that meeting, you’ll find out that the client and the visual designer decided to change a bunch of the typography. Now you need to go back and change it in 293 places in the CSS file. If you get paid by the hour, that might be great!

As you begin to adjust the rules, things will start to conflict. That rule that worked for two things now only works for the one. Or you’ll notice patterns that could now be used in many more places than before. You may even be tempted to just totally delete the CSS and start over! Yikes!

I won’t write it out here, but you’ll try a bunch of different things over time, and people usually come to the conclusion that you can create a class — and add it to the element instead of duplicating rules/declarations for every element. You’ll go even further to try and pull patterns out of the visual designer’s documents. (You might even round a few 19px down to 18px without telling them…)

.standard-text { /* or something */
  font-family: serif;
  font-size: 16px; /* px: up for debate */
  line-height: 1.4; /* no unit: so it's relative to the font-size */
  letter-spacing: 0.02em; /* em: so it's relative to the font-size */
}

.heading-1 {
  font-family: sans-Serif;
  font-size: 30px;
  line-height: 1.5;
  letter-spacing: 0.03em;
}

.medium-heading {
  font-family: sans-Serif;
  font-size: 24px;
  line-height: 1.3;
  letter-spacing: 0.04em;
}

Then you’d apply the class to anything that needs it.

<header class="site-header">
  <h1 class="page-title heading-1">
    Be <mark>excellent</mark> to each other
  </h1>
</header>

<main class="page-content">
  <section class="welcome">
    <h2 class="medium-heading">Party on <em>dudes</em></h2>

    <p class="standard-text">And yeah. I'm just regular</p>
  </section>
</main>

This way of doing things can be really helpful for teams that have people of all skill levels changing the HTML. You can plug and play with these CSS classes to get the style you want, even if you’re the new intern.

It’s really helpful to separate the idea of “layout” elements (structure/parents) and the idea of “modules” or “components.” In this way, we’re treating the pieces of text as lower level components.

The key is to keep the typography separate from the layout. You don’t want all .medium-heading elements to have the same margins or colors. It’s going to depend on where they are. This way you are styling based on context. You aren’t ‘using’ the cascade necessarily, but you also aren’t fighting it because you keep the techniques separate.

.site-header {
  padding: 20px 0;
}

.welcome .medium-heading { /* the context — not the type-pattern */
  margin-bottom: 10px;
}

This is keeping things reasonable and tidy. This technique is used all over the web.

Working with a CMS

Great, but what about situations where you can’t change the HTML?

You might just be typing up a quick CodePen or a business-card site. In that case, these concerns are going to seem like overkill. On the other hand, you might be working with a CMS where you aren’t sure what is going to happen. You might need to plan for anything and everything that could get thrown at you. In those cases, you’re unable to simply add classes to individual elements. You’re likely to get a dump of HTML from some templating language.

<?php echo getContent()?>
<?=getContent()?>
${data.content}
{{model.cmsContent}}

So, if you can’t work with the HTML what can you do?

<article class="post cms-blog-dump">
  <h1>Talking type-patterns on CSS-tricks</h1>
  <p>Intoduction paragraph - and we'd like to style this with a slightly different size font then the next (normal) paragraphs</p>
  <h2>Some headings</h2>
  <h2>And maybe someone accidentally puts 2 headings in a row</h2>
  <ol>
    <li>and some <strong>list</strong></li>
    <li>and here</li>
  </ol>

  <p>Or if a blog post is too boring - then think of a list of bands on an event site. You never know how many there will be or which ones are headlining, so you have to write rules that will handle whatever happens.
</article>

You don’t have any control over this markup, so you won’t be able to add classes, meaning that the cool plug-and-play classes you made aren’t going to work! You might just copy and paste them into some larger .article { } class that defines the rules for a kitchen sink. That could work.

What other tools are there to play with?

Mixins

If you could create some reusable concept of a “type pattern” with Sass, then you could apply those in a similar way to how the classes work.

@mixin my-useful-rule { /* define the mixin */
  background-color: blue;
  color: lime;
}

.thing {
  @include my-useful-rule(); /* employ the mixin */
}

/* This compiles to: */
.thing {
  background-color: blue;
  color: lime;
}
/* (just so that we're on the same page) */

Less, Sass, Stylus and other CSS preprocessors all have their own syntax for this. I’m going to use Sass/SCSS in these examples because it is the most common at the time of writing.

@mixin standard-type() { /* define the mixin */
  font-family: Serif;
  font-size: 16px;
  line-height: 1.4;
  letter-spacing: 0.02em;
}

.context .thing {
  @include standard-type(); /* employ it in context */
}

You can use heading-1() and heading-2() and a lot of big-name style guides do this. But what if you want to use those type styles on something that isn’t a “heading”? I personally don’t end up connecting the headings with “size” and I use the patterns in all sorts of different places. Sometimes my headings are “mean” and “stout.” They can be piercing red and uppercase with the same x-height as the paragraph text.

Instead, I define the visual styles in association with how I want the “voice” of the content to come across. This also helps the team discuss “tone” and other content strategy stuff across disciplines.

For example, in Jason Santa Maria’s book, On Web Typography, he talks about “type for a moment” and “type to live with.” There’s type to grab your attention and break up the page, and then those paragraphs to settle into. Instead of .standard-text or .normal-font, I’ve been enjoying the idea of organizing styles by voice. This is all that type that a user should spend time consuming. It’s what I’d likely use for most paragraphs and lists, and I won’t set it on the body.

@mixin calm-voice() { /* define the mixin */
  font-family: Serif;
  font-size: 16px;
  line-height: 1.4;
  letter-spacing: 0.02em;
}

@mixin loud-voice() {
  font-family: Sans-Serif;
  font-size: 30px;
  line-height: 1.5;
  letter-spacing: 0.03em;
}

@mixin attention-voice() {
  font-family: Sans-Serif;
  font-size: 24px;
  line-height: 1.3;
  letter-spacing: 0.04em;
}

This idea of “voices” helps me keep things meaningful because it requires you to name things by the context. The name heading-1b, for example, doesn’t help me connect to the content to any sort of storytelling or to the other people on the team.

Now to style the mystery article. I’ll be using SCSS syntax here:

article {
  padding: 20px 0;
  h1 {
    @include loud-voice();
    margin-bottom: 20px;
  }
  h2 {
    @include attention-voice();
    margin-bottom: 20px;
  }
  p {
    @include calm-voice();
    margin-bottom: 10px;
  }
}

Pretty, right?

But it’s not that easy, is it? No. It’s a little more complicated because you don’t know what might be above or below each other — or what might be left out, because articles aren’t always structured or organized the same. Those CMS authors can put whatever they want in there! Three <h3> elements in a row? You have to prepare for lots of possible outcomes.

/* Styles */
article {
  padding: 20px 0;

  h1 {
    @include loud-voice();
  }

  h2 {
    @include attention-voice();
  }

  p {
    @include calm-voice();

    &:first-of-type {
      background: lightgreen;
      padding: 1em;
    }
  }

  ol {
    @include styled-ordered-list();
  }

  * + * {
    margin-top: 1em 
  }
}

To see the regular CSS you can always “View Compiled” in CodePen.

Some people are really happy with the lobotomized owl approach (* + *) but I usually end up writing explicit rules for “any <h2> that comes after a paragraph” and getting really detailed. After all, it’s the written content that everyone wants to read… and I really only need to dial it in one time in one place.

/* Slightly more filled out pattern */
@mixin calm-voice() {
  font-family: serif;
  font-size: 16px;
  line-height: 1.4;
  letter-spacing: 0.02em;
  max-width: 80ch;

  strong {
    font-weight: 700;
  }

  em {
    font-style: italic;
  }

  mark {
    background-color: wheat;
  }

  sup {
    /* maybe? */
  }

  a {
    text-decoration: underline;
    color: $highlight;
  }

  @media (min-width: 600px) {
    font-size: 17px;
  }
}

Stylus

It’s nice to think about the “ideal” workflow. What could browsers implement that would make this fun and play well with their future systems?

Here’s an example of the most stripped down preprocessor syntax:

calm-voice()
  font-family: serif
  font-size: 16px
  line-height: 1.4
  letter-spacing: 0.02em

article
  h1
    loud-voice()
  h2
    attention-voice()
  p
    calm-voice()

I’ll be honest… I love Stylus. I love writing it, and I love using it for examples. It keeps people on their toes. It’s so fast to type in CodePen! If you already have your own little framework of styles like this, it’s insane how fast you can build UI. But! The tooling has fallen behind and at this point, I can’t recommend that anyone use it.

I only add it here because it’s important to dream. We have what we have, but what if you could invent a new way of writing it? That’s a crucial part of the conversation too. If you can’t describe what you want, you wont get it.

We’re here: Type Patterns

Can you see where all of this is going?

You can use these “patterns” or “mixins’ or “whatever” you want to call them and plug and play. It’s fun. And you can totally combine it with the utility class idea too (if you must).

.calm-voice {
  @include calm-voice();
}
<p class="calm-voice">Welcome to this code snippet!</p>

Style guides

If you can start to share a common language and break down the barriers between “creatives” and “coders,” then everyone can work with these type patterns in mind from the start.

Sometimes you can simply publish a style guide as a “brand” subdomain or directly on the site, like at /style-guide. There are tons of these floating around on the web. The point is that some style guides are standalone, and others are built into the site itself. Wherever they go, they are considered “live” and they allow you to develop things in one place that take effect globally, and use the guide itself as a sort of artifact.

By building live style guides with type patterns as a core and shared concept, everyone will have more fun and save time trying to figure out what each other means. It’s not just for big companies either.

Just be mindful when looking at style guides for other organizations. Style guides serve different purposes depending on who is using them and how, so simply diving into someone else’s work could actually contribute more confusion.

Known unknowns

Sometimes you don’t know what the content will be. That means CMS stuff, but also logic. What if you have a list of bands and events and you are building a module full of conditional components? There might be one band… or five… or two co-headliners. The event might be cancelled!

When I was trying to work out some templating ideas for Ticketfly, I separated the concerns of layout and type patterns.

Variable sized font patterns

Some patterns change sizes at various breakpoints.

@mixin attention-voice() {
  font-family: Serif;
  font-size: 20px;
  line-height: 1.4;
  letter-spacing: 0.02em;
  @media (min-width: 700px) {
    font-size: 24px;
  }
  @media (min-width: 1100px) {
    font-size: 30px;
  }
}

I used to do something like this and it had a few yucky side effects. For example, what if you plug and play based on the breakpoints and there are sizes that conflict or slip through?

clamp() and vmin units to the rescue!

@mixin attention-voice() {
  font-family: Serif;
  font-size: clamp(18px, 10vmin, 100px);
  line-height: 1.4;
  letter-spacing: 0.02em;
}

Now, in theory, you could even jump between the patterns with no rub.

.context {
  @include calm-voice();
  @media (min-width: 840px) {
    @include some-other-voice();
  }
}

But now you have to make sure that they both have the same properties and that they don’t conflict with or bleed through to others! And think about the new variable font options too. Sometimes you’ll want your heading to be a little less heavy on smaller screens or a little taller to work with the space.

Aren’t you duplicating style rules all over the place?

Yikes! You caught me. I care way more about making the authoring and maintaining process pleasurable than I care about CSS byte size. I’m conflicted though. I get it. But I also think that the solution should happen somewhere else in the pipeline. There’s a reason that we don’t write machine code by hand.

Sometimes you have to examine a programming pattern closely and really poke at it, trying it in every place you can to prove how useful it is. Humor me for a movement and look at how you’d use this type pattern and other mixins to style a common “card” interface.

In a way, type patterns are like the utility class style of Bootstrap or Tailwind. But these are human readable. The patterns are added in the CSS instead of the HTML. The concept is the same. I like to think that anyone could look at the living style guide and jump into a component and style it. What do you think?

It is creating more CSS though. Those kilobytes are stacking up. But I think we should work towards something ideal instead of just “possible.” We can probably build something that works this out at build time. I’ll have to learn more about the CSSOM and there are many new things coming down the pipeline that could make this possible without a preprocessor.

It’s bigger than just the CSS. It’s about the people.

Having a set of patterns for type in your project allows visual designers to focus on their magic. More and more, we are building fast and in the browser. Visual designers focus on feel and typography and color with simple frameworks, like Style Tiles. Then developers can organize the data, resource structures and layouts, and everyone can work at the same time. We can have clearer communication and shared understanding of the entire process. We are all UX designers.

When living style guides are created as a team, there’s a lot less need for pixel-pushing. Visual designers can actually spend more time thinking and trying ideas in prototypes, and less time mocking out unnecessary production art. This allows you to work on your brand as a whole and have one single source of truth. It even helps with really small sites, like this.

Gold Collective style guide

InDesign and Illustrator have always had “paragraph styles” and “character styles” for this reason, but they don’t take into account variable screen sizes.

Toss in a few padding type sizes/ratios, some colors and some line widths. It doesn’t have to really be “pixel perfect” but more of a collection of patterns that work together. Colors as variables and maybe some $thick, $thin, or $pad*2 type conventions can help streamline design patterns.

You can find your inspiration in the graphics program, then jump straight to the live style guide. People of all backgrounds can start playing with the styles in a CodePen and dial them in across devices.

In the end, you’ll decide the details on real devices — together, as a team.



Source link