CSS Archives - Online Code Generator

Why Do Some Programmers Say Frontend Is Easier Than Backend?

Posted on February 24, 2023May 21, 2023 by Mark FeehilyComments Off

So, you’re wondering if frontend development is easier than backend development. Truth be told, the question is rather challenging. Frontend and backend development are two somewhat complicated aspects of web development in 2023. Fortunately for you, we’ll determine which type of development is more challenging in this article: frontend or backend!

Do you ever wonder why so many backend developers say that frontend is easier? Discover the answer to this and many other related questions in this article! Have you ever asked yourself questions like What makes frontend easier than backend? What skills are needed to become a successful frontend developer? or What techniques do developers use to make the frontend development process easier?

It is well known that backend development is more difficult than frontend development. A study by the University of Oxford found that “Backend developers tend to have a higher workload than frontend developers, due to the complexity of the programming language used”. The same study also noted that “The complexity of the backend language also means that backend developers need to have a higher level of technical knowledge than frontend developers”.

In this article, you will learn why so many backend developers say that frontend is easier, what skills are needed to become a successful frontend developer, and what techniques are used to make the frontend development process easier. After reading this article, you will have a better understanding of why frontend is easier than backend and why it is important to learn both.

Is Frontend Development Easier Than Backend?

During the past decade, frontend development has grown in popularity as more engineers switch from backend development to frontend. Due to its greater availability and perception as being “easier” than backend development, frontend programming has the propensity to be used more frequently. The primary reason so many developers like the frontend are its simplicity. Frontend development has a lower learning curve and calls for less technical knowledge than backend programming. This makes it possible for developers to get started straight away even with just a basic understanding of HTML, CSS, and JavaScript.

Moreover, several frontend frameworks, such as React and Vue, have made it simpler for developers to create working prototypes of websites fast. The tools available are another reason frontend development is perceived as being simpler. Website development is made simpler for developers by the abundance of tools, libraries, and frameworks available. As an illustration, CSS preprocessors like Sass and LESS may significantly cut down on the time required to develop and maintain CSS code. The same is true for JavaScript build tools like webpack and gulp, which may assist developers in writing task automation and optimized code.

The fact that frontend development is more visible and tangible than backend development is a last consideration. As a result, developers can more easily comprehend and interact with the code they write since they can view the results of their labors in real-time in the browser. Developers may be highly motivated by this and debugging and troubleshooting are also much facilitated. In conclusion, many backend engineers assert that the frontend is simpler since it is more approachable, has access to tools, and is more visible and concrete. Because of this, a lot of developers are switching from the backend to the frontend, and this trend is probably going to continue.

What is Frontend & Backend Development?

Frontend development (client-side development) refers to the development of the parts of a website that the user can see and interact with. This includes code that is responsible for the look, feel, and behavior of the website and includes HTML, CSS, and JavaScript.

Backend development (server-side development) is the creation of sections of a website that the user does not directly view or interact with. This contains program code for databases, servers, and APIs that manage and handle the website’s data.

What’s the Difference?

The main distinction between frontend and backend development is that the former concentrates on the external components of the website, whilst the latter does so for its internal components. Backend development is in charge of data processing and storage, whereas frontend development is in charge of the appearance, feel, and functionality of the website.

Frontend developers build the aesthetics, style, and interaction of the user interface using HTML, CSS, and JavaScript. The logic, databases, and APIs that power the user interface are created by backend developers in languages like PHP, Python, Java, and Ruby. Backend development is concerned with how the user interface works and interacts with the server-side logic and data, whereas frontend development is concerned with how the user interface appears and feels.

Why Is Frontend Harder Than Backend?

Why is it that some claim that frontend development is more difficult than backend development these days? There are several reasons why this is so, let’s look at them.

Keeping up with a rapidly changing environment

The rapid advancements in frontend development have given it a reputation for being challenging. Every few months, new frameworks and technologies like React, Angular, and Vue are released to improve development. These continual updates mean that staying up-to-date requires constant learning of new lessons and courses. Once Angular was the most popular frontend framework, but now React is the preferred choice for many companies. Even Netflix has gone back to using the original JavaScript due to performance concerns. With no indication that these advances will soon slow down, it’s important to remember how quickly the industry is developing the next time someone claims that frontend development is easy.

More information to consider

Frontend development may prove to be equally challenging in 2023 as backend development. With opinionated frameworks, state management systems, and intricate logic, there should be no assumption that the workload for backend developers is greater than that of frontend developers. However, frontend development entails more than just programming, as it demands creativity, aesthetics, and an understanding of user experience. This includes being adept with design techniques, creating prototypes, and making sure the design looks professional. Furthermore, it necessitates taking into account how users will interact with the software to deliver the best user experience.

More tools to learn

As the workplace evolves, so too must your skillset. Keeping up with the latest tools, such as Webpack, React, Yarn, and NPM can be a challenge, as you may find yourself constantly learning new technologies, leaving less time to learn other programming topics, such as different paradigms, languages, and best practices. Nevertheless, it is important to remain up-to-date and not be discouraged by the ever-changing landscape.

Test suites and testing

Testing the frontend of a web application is more difficult and tedious than the back end. In addition to checking for the theoretical soundness of functions and objects, and assessing edge scenarios, frontend testing requires tests for design components, logical operations, and state changes. As such, manual testing is often preferred over creating a unit test suite, which is more time-consuming and frustrating. All in all, frontend testing is more complex, laborious, and frustrating than backend testing.

Why Is Backend Harder Than Frontend?

Both backend and frontend development have specific explanations for why they are more difficult.

The higher learning curve for beginners

Compared to frontend development, learning backend programming can be more difficult. To build a website’s frontend, only HTML and CSS are needed. However, the backend requires a deep understanding of programming languages. This can be daunting for newcomers and lead them to believe that frontend development is easier. In reality, the learning curve for the backend is much steeper than for the frontend.

Frontend is less visually appealing than the backend

Just knowing where to look can help you find the backend, which can be just as aesthetically pleasing as the frontend. However, with frontend development, you can often see the effects of your changes in real time. The response time for the backend can be unpredictable, making it more challenging for a beginner.

Many backend languages

The complexity of learning backend languages can be attributed to their variety and the need to comprehend multiple languages. While frontend development only requires knowledge of JavaScript, HTML, and CSS, backend development involves mastering three languages to work with the various methods available. Although the concepts are generally the same, transitioning between languages can be challenging, leading many to stick with the language they are most comfortable with or switch only when necessary for a better career opportunity.

Summary

So, which is harder, the backend or the frontend? The truth is that both types of development are equally difficult, but for different reasons. Frontend development necessitates comprehension of design concepts and user experience, as well as the ability to produce an aesthetically beautiful user interface. Awareness of server architecture, security, and strong technical language and framework knowledge are all necessary for backend development. In the end, both styles of development are essential for a successful product, and they each call for a unique set of talents. The distinctions between the two and the many tasks that each may be utilized for must be understood. You can more readily pick which form of growth is best for you if you are aware of the distinctions.

The post Why Do Some Programmers Say Frontend Is Easier Than Backend? appeared first on Flatlogic Blog.

Java-Script Jarre

Posted on January 14, 2023May 21, 2023 by Mark FeehilyComments Off

#621 — January 13, 2023

Read on the Web

JavaScript Weekly

The State of JS 2022 — The State of JS is one of the JavaScript ecosystem’s most popular surveys and this time 39,471 folks took part giving us a snapshot of the tools, technologies, and language features people are using (or not using!) There’s a lot to go through, but here are some key points:

top-level await is the most newly adopted feature recently.
The JavaScript / TypeScript balance shows a majority of developers using TypeScript over JS.
Express remains by far the most popular backend framework with Nest, Fastify, Strapi, and Koa following somewhat behind.
Other interesting results can be found in JS pain points, what is currently missing from JS, and the ‘Awards’ for stand out items (complete with snazzy visual effects).

Devographics

? Retire your Legacy CMS with ButterCMS — ButterCMS is your new content backend. We’re SaaS so we host, maintain, and scale the CMS. Enable your marketing team to update website + app content without needing you. Try the #1 rated SaaS Headless CMS for your JS app today. Free for 30 days.

? ButterCMS sponsor

? Is TypeScript Worth It? — Time saver or waste of time? The relationship between TypeScript and JavaScript remains a complex one. An extensive discussion took place on Hacker News this week and, notably, TypeScript PM Daniel Rosenwasser popped up to respond to some of the concerns.

Hacker News

IN BRIEF:

You’ll be aware of JavaScript’s strict mode but one developer thinks we need a stricter mode to fix several other syntax issues.

Publint is an online tool for ‘linting’ live npm packages to see if they are packaged correctly, as a way to ensure maximum compatibility across environments.

RELEASES:

Node v19.4.0 and v18.13.0 (LTS)

Commander.js 9.5
↳ Node.js command-line interface toolkit.

Angular 15.1

Pixi.js 7.1 – Fast 2D on WebGL engine.

? Articles & Tutorials

The Gotcha of Unhandled Promise Rejections — A rough edge with promises that can sneak up on you. Jake looks at a ‘gotcha’ around unhandled promise rejections and how to work around it.

Jake Archibald

HTML with Superpowers: The Guidebook — A free resource introducing Web Components, what they are, and what problems they’re trying to solve. You can see the Guidebook directly here.

Dave Rupert

With Retool You Ship Apps Fast with 100+ Perfectly Crafted UI Components — The fast way for devs to build and share internal tools. Teams at companies like Amazon, DoorDash & NBC collaborate around custom-built Retool apps to solve internal workflows.

Retool sponsor

Everything About React’s ‘Concurrent Mode’ Features — An in-depth, example-led exploration of Concurrent Mode (now more a set of features integrated into React 18 than a distinct ‘mode’).

Henrique Yuji

Using GitHub Copilot for Unit Testing? — Even if you find the idea of a AI tool like Copilot writing production code distasteful, it may have a place in speeding up writing tests.

Ianis Triandafilov

How to Destructure Props in Vue (Composition API) — How to correctly destructure props object in a Vue component while maintaining the reactivity.

Dmitri Pavlutin

Using Inline JavaScript Modules to Prevent CSS Blockage

Stoyan Stefanov

How to Build a GraphQL Server with Deno

Andy Jiang

? Code & Tools

Gluon: Framework for Creating Desktop Apps from Sites — A new approach for building desktop apps on Windows and Linux from Web sites using Node (or Deno) and already installed browsers (Chromium or Firefox). Initial macOS support has just been added too.

Gluon

Structura.js: Lightweight Library for Immutable State Management — ” It is based on the idea of structural sharing. The library is very similar to Immer.js, but it has some advantages over it.”

Giuseppe Raso

Tuple, a Lightning-Fast Pairing Tool Built for Remote Developers — High-resolution, crystal-clear screen sharing, low-latency remote control, and less CPU usage than you’d think possible.

Tuple sponsor

Bay.js: A Lightweight Library for Web Components — Makes it easy to create web components that can be reused across projects. It also boasts performant state changes and secure event binding.

Ian Dunkerley

Twify: Scaffold a Tailwind CSS Project with a Single Command — You can use your preferred package manager and it supports creating projects with Next.js, Nuxt 2/3, SvelteKit, Remix, Angular, and more.

Kazi Ahmed

Lazy Brush 2.0: A Library for Smooth Pointer Drawing — Allow your users to draw smooth curves and straight lines with your mouse, finger or any pointing device. This long standing library has just migrated to TypeScript and gained a new ‘friction’ option to customize the feel. GitHub repo.

Jan Hug

➗ Mafs: React Components for Interactive Math — Build interactive, animated visualizations using declarative code with illustrative demos like bezier curves. The documentation is fantastic – check out how easy it is to make plots. Or just head to the GitHub repo.

Steven Petryk

Are You Looking for a New Observability Tool?

TelemetryHub by Scout sponsor

Hyphenopoly 5.0: A Polyfill for Client-Side Hyphenation — An interesting use of WebAssembly here.

Mathias Nater

visx 3.0
↳ D3-powered visualization React components.

Atrament 3.0
↳ Library for drawing and handwriting on a canvas element.

HLS.js 1.3
↳ Library to play HLS (HTTP Live Streaming) in browsers, with MSE support.

? Jobs

Developer Relations Manager — Join the CKEditor team to build community around an Open Source project used by millions of users around the world ?

CKEditor

Backend Engineer, TypeScript (Berlin / Remote) — Thousands of people love our product (see Trustpilot for yourself). Join the team behind it and help us scale. ?

Feather

Find JavaScript Jobs with Hired — Create a profile on Hired to connect with hiring managers at growing startups and Fortune 500 companies. It’s free for job-seekers.

Hired

? Écoute la musique..

Oxygene Pt 4, as Performed by JavaScript — This is fun. Dittytoy is a simple, JavaScript-powered online generative music tool and someone has put together a surprisingly faithful rendition of perhaps one of the best known instrumental synth songs ever, all the way from 1976.

Dittytoy

Introducing Finch: An Open Source Client for Container Development

Posted on January 14, 2023May 21, 2023 by Mark FeehilyComments Off

Today we are happy to announce a new open source project, Finch. Finch is a new command line client for building, running, and publishing Linux containers. It provides for simple installation of a native macOS client, along with a curated set of de facto standard open source components including Lima, nerdctl, containerd, and BuildKit. With Finch, you can create and run containers locally, and build and publish Open Container Initiative (OCI) container images.

At launch, Finch is a new project in its early days with basic functionality, initially only supporting macOS (on all Mac CPU architectures). Rather than iterating in private and releasing a finished project, we feel open source is most successful when diverse voices come to the party. We have plans for features and innovations, but opening the project this early will lead to a more robust and useful solution for all. We are happy to address issues, and are ready to accept pull requests. We’re also hopeful that with our adoption of these open source components from which Finch is composed, we’ll increase focus and attention on these components, and add more hands to the important work of open source maintenance and stewardship. In particular, Justin Cormack, CTO of Docker shared that “we’re bullish about Finch’s adoption of containerd and BuildKit, and we look forward to AWS working with us on upstream contributions.”

We are excited to build Finch in the open with interested collaborators. We want to expand Finch from its current basic starting point to cover Windows and Linux platforms and additional functionality that we’ve put on our roadmap, but would love your ideas as well. Please open issues or file pull requests and start discussing your ideas with us in the Finch Slack channel. Finch is licensed under the Apache 2.0 license and anyone can freely use it.

Why build Finch?

For building and running Linux containers on non-Linux hosts, there are existing commercial products as well as an array of purpose-built open source projects. While companies may be able to assemble a simple command line tool from existing open source components, most organizations want their developers to focus on building their applications, not on building tools.

At AWS, we began looking at the available open source components for container tooling and were immediately impressed with the progress of Lima, recently included in the Cloud Native Computing Foundation (CNCF) as a sandbox project. The goal of Lima is to promote containerd and nerdctl to Mac users, and this aligns very well with our existing investment in both using and contributing to the CNCF graduated project, containerd. Rather than introducing another tool and fragmenting open source efforts, the team decided to integrate with Lima and is making contributions to the project. Akihiro Suda, creator of nerdctl and Lima and a longtime maintainer of containerd, BuildKit, and runc, added “I’m excited to see AWS contributing to nerdctl and Lima and very happy to see the community growing around these projects. I look forward to collaborating with AWS contributors to improve Lima and nerdctl alongside Finch.”

Finch is our response to the complexity of curating and assembling an open source container development tool for macOS initially, followed by Windows and Linux in the future. We are curating the components, depending directly on Lima and nerdctl, and packaging them together with their dependencies into a simple installer for macOS. Finch, via its macOS-native client, acts as a passthrough to nerdctl which is running in a Lima-managed virtual machine. All of the moving parts are abstracted away behind the simple and easy-to-use Finch client. Finch manages and installs all required open source components and their dependencies, removing any need for you to manage dependency updates and fixes.

The core Finch client will always be a curated distribution composed entirely of open source, vendor-neutral projects. We also want Finch to be customizable for downstream consumers to create their own extensions and value-added features for specific use cases. We know that AWS customers will want extensions that make it easier for local containers to integrate with AWS cloud services. However, these will be opt-in extensions that don’t impact or fragment the open source core or upstream dependencies that Finch depends on. Extensions will be maintained as separate projects with their own release cycles. We feel this model strikes a perfect balance for providing specific features while still collaborating in the open with Finch and its upstream dependencies. Since the project is open source, Finch provides a great starting point for anyone looking to build their own custom-purpose container client.

In summary, with Finch we’ve curated a common stack of open source components that are built and tested to work together, and married it with a simple, native tool. Finch is a project with a lot of collective container knowledge behind it. Our goal is to provide a minimal and simple build/run/push/pull experience, focused on the core workflow commands. As the project evolves, we will be working on making the virtualization component more transparent for developers with a smaller footprint and faster boot times, as well as pursuing an extensibility framework so you can customize Finch however you’d like.

Over time, we hope that Finch will become a proving ground for new ideas as well as a way to support our existing customers who asked us for an open source container development tool. While an AWS account is not required to use Finch, if you’re an AWS customer we will support you under your current AWS Support plans when using Finch along with AWS services.

What can you do with Finch?

Since Finch is integrated directly with nerdctl, all of the typical commands and options that you’ve become fluent with will work the same as if you were running natively on Linux. You can pull images from registries, run containers locally, and build images using your existing Dockerfiles. Finch also enables you to build and run images for either amd64 or arm64 architectures using emulation, which means you can build images for either (or both) architectures from your M1 Apple Silicon or Intel-based Mac. With the initial launch, support for volumes and networks is in place, and Compose is supported to run and test multiple container applications.

Once you have installed Finch from the project repository, you can get started building and running containers. As mentioned previously, for our initial launch only macOS is supported.

To install Finch on macOS download the latest release package. Opening the package file will walk you through the standard experience of a macOS application installation.

Finch has no GUI at this time and offers a simple command line client without additional integrations for cluster management or other container orchestration tools. Over time, we are interested in adding extensibility to Finch with optional features that you can choose to enable.

After install, you must initialize and start Finch’s virtual environment. Run the following command to start the VM:
finch vm init

To start Finch’s virtual environment (for example, after reboots) run:
finch vm start

Now, let’s run a simple container. The run command will pull an image if not already present, then create and start the container instance. The —rm flag will delete the container once the container command exits.

finch run –rm public.ecr.aws/finch/hello-finch
public.ecr.aws/finch/hello-finch:latest: resolved |++++++++++++++++++++++++++++++++++++++|
index-sha256:a71e474da9ffd6ec3f8236dbf4ef807dd54531d6f05047edaeefa758f1b1bb7e: done |++++++++++++++++++++++++++++++++++++++|
manifest-sha256:705cac764e12bd6c5b0c35ee1c9208c6c5998b442587964b1e71c6f5ed3bbe46: done |++++++++++++++++++++++++++++++++++++++|
config-sha256:6cc2bf972f32c6d16519d8916a3dbb3cdb6da97cc1b49565bbeeae9e2591cc60: done |++++++++++++++++++++++++++++++++++++++|
elapsed: 0.9 s total: 0.0 B (0.0 B/s)

@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@ @@@@@@@@@@@
@@@@@@@ @@@@@@@
@@@@@@ @@@@@@
@@@@@@ @@@@@
@@@@@ @@@# @@@@@@@@@
@@@@@ @@ @@@ @@@@@@@@@@
@@@@% @ @@ @@@@@@@@@@@
@@@@ @@@@@@@@
@@@@ @@@@@@@@@@@&
@@@@@ &@@@@@@@@@@@
@@@@@ @@@@@@@@
@@@@@ @@@@@(
@@@@@@ @@@@@@
@@@@@@@ @@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@

Hello from Finch!

Visit us @ github.com/runfinch

Lima supports userspace emulation in the underlying virtual machine. While all the images we create and use in the following example are Linux images, the Lima VM is emulating the CPU architecture of your host system, which might be 64-bit Intel or Apple Silicon-based. In the following examples we will show that no matter which CPU architecture your Mac system uses, you can author, publish, and use images for either CPU family. In the following example we will build an x86_64-architecture image on an Apple Silicon laptop, push it to ECR, and then run it on an Intel-based Mac laptop.

To verify that we are running our commands on an Apple Silicon-based Mac, we can run uname and see the architecture listed as arm64:

uname -sm
Darwin arm64

Let’s create and run an amd64 container using the –platform option to specify the non-native architecture:

finch run –rm –platform=linux/amd64 public.ecr.aws/amazonlinux/amazonlinux uname -sm
Linux x86_64

The –platform option can be used for builds as well. Let’s create a simple Dockerfile with two lines:

FROM public.ecr.aws/amazonlinux/amazonlinux:latest
LABEL maintainer=”Chris Short”

By default, Finch would build for the host’s CPU architecture platform, which we showed is arm64 above. Instead, let’s build and push an amd64 container to ECR. To build an amd64 image we add the –platform flag to our command:

finch build –platform linux/amd64 -t public.ecr.aws/cbshort/finch-multiarch .
[+] Building 6.5s (6/6) FINISHED
=> [internal] load build definition from Dockerfile 0.1s
=> => transferring dockerfile: 142B 0.0s
=> [internal] load .dockerignore 0.1s
=> => transferring context: 2B 0.0s
=> [internal] load metadata for public.ecr.aws/amazonlinux/amazonlinux:latest 1.2s
=> [auth] aws:: amazonlinux/amazonlinux:pull token for public.ecr.aws 0.0s
=> [1/1] FROM public.ecr.aws/amazonlinux/amazonlinux:[email protected]:d0cc2f24c888613be336379e7104a216c9aa881c74d6df15e30286f67 3.9s
=> => resolve public.ecr.aws/amazonlinux/amazonlinux:[email protected]:d0cc2f24c888613be336379e7104a216c9aa881c74d6df15e30286f67 0.0s
=> => sha256:e3cfe889ce0a44ace07ec174bd2a7e9022e493956fba0069812a53f81a6040e2 62.31MB / 62.31MB 5.1s
=> exporting to oci image format 5.2s
=> => exporting layers 0.0s
=> => exporting manifest sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652 0.0s
=> => exporting config sha256:474c401eafe6b05f5a4b5b4128d7b0023f93c705e0328243501e5d6c7d1016a8 0.0s
=> => sending tarball 1.3s
unpacking public.ecr.aws/cbshort/finch-multiarch:latest (sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652)…
Loaded image: public.ecr.aws/cbshort/finch-multiarch:latest%

finch push public.ecr.aws/cbshort/finch-multiarch
INFO[0000] pushing as a reduced-platform image (application/vnd.docker.distribution.manifest.v2+json, sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652)
manifest-sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652: done |++++++++++++++++++++++++++++++++++++++|
config-sha256:474c401eafe6b05f5a4b5b4128d7b0023f93c705e0328243501e5d6c7d1016a8: done |++++++++++++++++++++++++++++++++++++++|
elapsed: 27.9s total: 1.6 Ki (60.0 B/s)

At this point we’ve created an image on an Apple Silicon-based Mac which can be used on any Intel/AMD CPU architecture Linux host with an OCI-compliant container runtime. This could be an Intel or AMD CPU EC2 instance, an on-premises Intel NUC, or, as we show next, an Intel CPU-based Mac. To show this capability, we’ll run our newly created image on an Intel-based Mac where we have Finch already installed. Note that we have run uname here to show the architecture of this Mac is x86_64, which is analogous to what the Go programming language references 64-bit Intel/AMD CPUs as: amd64.

uname -a
Darwin wile.local 21.6.0 Darwin Kernel Version 21.6.0: Thu Sep 29 20:12:57 PDT 2022; root:xnu-8020.240.7~1/RELEASE_X86_64 x86_64

finch run –rm –platform linux/amd64 public.ecr.aws/cbshort/finch-multiarch:latest uname -a
public.ecr.aws/cbshort/finch-multiarch:latest: resolved |++++++++++++++++++++++++++++++++++++++|
manifest-sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652: done |++++++++++++++++++++++++++++++++++++++|
config-sha256:474c401eafe6b05f5a4b5b4128d7b0023f93c705e0328243501e5d6c7d1016a8: done |++++++++++++++++++++++++++++++++++++++|
layer-sha256:e3cfe889ce0a44ace07ec174bd2a7e9022e493956fba0069812a53f81a6040e2: done |++++++++++++++++++++++++++++++++++++++|
elapsed: 9.2 s total: 59.4 M (6.5 MiB/s)
Linux 73bead2f506b 5.17.5-300.fc36.x86_64 #1 SMP PREEMPT Thu Apr 28 15:51:30 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

You can see the commands and options are familiar. As Finch is passing through our commands to the nerdctl client, all of the command syntax and options are what you’d expect, and new users can refer to nerdctl’s docs.

Another use case is multi-container application testing. Let’s use yelb as an example app that we want to run locally. What is yelb? It’s a simple web application with a cache, database, app server, and UI. These are all run as containers on a network that we’ll create. We will run yelb locally to demonstrate Finch’s compose features for microservices:

finch vm init
INFO[0000] Initializing and starting finch virtual machine…
INFO[0079] Finch virtual machine started successfully

finch compose up -d
INFO[0000] Creating network localtest_default
INFO[0000] Ensuring image redis:4.0.2
docker.io/library/redis:4.0.2: resolved |++++++++++++++++++++++++++++++++++++++|
index-sha256:cd277716dbff2c0211c8366687d275d2b53112fecbf9d6c86e9853edb0900956: done |++++++++++++++++++++++++++++++++++++++|

[ snip ]

layer-sha256:afb6ec6fdc1c3ba04f7a56db32c5ff5ff38962dc4cd0ffdef5beaa0ce2eb77e2: done |++++++++++++++++++++++++++++++++++++++|
elapsed: 11.4s total: 30.1 M (2.6 MiB/s)
INFO[0049] Creating container localtest_yelb-appserver_1
INFO[0049] Creating container localtest_redis-server_1
INFO[0049] Creating container localtest_yelb-db_1
INFO[0049] Creating container localtest_yelb-ui_1

The output indicates a network was created, many images were pulled, started, and are now all running in our local test environment.

In this test case, we’re using Yelb to figure out where a small team should grab lunch. We share the URL with our team, folks vote, and we see the output via the UI:

What’s next for Finch?

The project is just getting started. The team will work on adding features iteratively, and is excited to hear from you. We have ideas on making the virtualization more minimal, with faster boot times to make it more transparent for users. We are also interested in making Finch extensible, allowing for optional add-on functionality. As the project evolves, the team will direct contributions into the upstream dependencies where appropriate. We are excited to support and contribute to the success of our core dependencies: nerdctl, containerd, BuildKit, and Lima. As mentioned previously, one of the exciting things about Finch is shining a light on the projects it depends upon.

Please join us! Start a discussion, open an issue with new ideas, or report any bugs you find, and we are definitely interested in your pull requests. We plan to evolve Finch in public, by building out milestones and a roadmap with input from our users and contributors. We’d also love feedback from you about your experiences building and using containers daily and how Finch might be able to help!

Live View Iframe Sizing

Posted on May 23, 2022May 21, 2023 by Mark Feehily0

Lee Martin had a good idea here. On CodePen’s Live View, we use a parent<iframe> to listen for updates to the Pen and then inject them or refresh the preview automatically. But that parent <iframe> can be tricky to size.

For example, on iOS, the height of the iframe was as tall as the content inside it and you can no control at all over that. In recent versions of iOS, that seems fixed. But we ran into a new problem. We sized the iframe to be as tall as the browser window by setting height: 100vh. That mostly works, but unfortunately, browser UI could sometimes overlap the bottom. That seems incredibly silly, but that’s the way it is. Fortunately, there is a brand new CSS things called dynamic viewport units, and Bramus has a good rundown. Now we’re (progressively) setting height: 100svh or the “Small Viewport”:

The Small Viewport is the viewport sized assuming any UA interfaces that are dynamically expanded and retracted to be *expanded*.

It looks like “dynamic” viewport units could have worked as well, but “small” seemed to work the same here and somehow feels safer. This is on production now, but see this video as I was kinda sorting this out:

https://videopress.com/v/mK4YyZqk?resizeToParent=true&cover=true&preloadContent=metadata&useAverageColor=true

Test Pen

Felt like an appropriate thing to work on for Global Accessibility Awareness Day (GAAD).

The post Live View Iframe Sizing appeared first on CodePen Blog.

One Weird Trick to Try @parcel/css on CodePen

Posted on May 16, 2022May 21, 2023 by Mark Feehily0

Ideally, we’d just offer @parcel/css as a CSS processor choice right in our editors. We could absolutely do that, but we’re smack in the middle of a bunch of next-gen CodePen stuff, and we’re keeping our efforts focused there. Never fear, interesting new processors like this will be there along with it. But this CSS processor caught my eye especially because it’s a very fresh, modern, and interesting take on CSS processing. It handles vendor prefixing on its own (something you might otherwise use Autoprefixer for), it handles “syntax lowering” (love that term) for future-syntax CSS (like you’d use postcss-preset-env for), offers scoping, and even has its own built-in minifier, while being super fast. Nice!

So what if you do wanna try it on CodePen? Well, it’s actually possible because they have cleverly released the processor with a Wasm option, not just a backend-language-only thing. So here’s the plan:

Load the processor in the browser as a script (go Wasm go!)
Pull the CSS from the current Pen
Pass that CSS to the in-browser processor we just loaded
Get the transformed CSS
Replace the CSS in the preview with the transformed CSS

Check it:

CodePen Embed Fallback

The post One Weird Trick to Try @parcel/css on CodePen appeared first on CodePen Blog.

What is Material UI

Posted on March 16, 2022May 21, 2023 by Mark Feehily0

Introduction

Material-UI (MUI) is a CSS framework that provides React components out-of-the-box and follows Google’s Material Design launched in 2014. MUI makes it possible to use different components to create a UI for a company’s web and mobile apps. Google uses Material Design to guarantee that no matter how users interact with the products they use, they will have a consistent experience. Material Design includes guidelines for typography, grid, space, scale, color, images, etc. And it also allows designers to build deliberate designs with hierarchy, meaning, and a focus on results.

The MUI library for React has over 76k stars on GitHub and is one of the most improved UI libraries. You can build an incredibly stylish application in a short amount of time with pre-styled components, as well as tune and expand these components according to your needs. It is based on Leaner Style Sheets (LESS), a CSS development extension.

You can also install the MUI into your application using yarn:

yarn add @material-ui/core

or npm:

npm i @material-ui/core

Why use Material UI?

Here are the reasons why developers prefer to integrate MUI into their applications:

Pre-designed UI components. MUI supplies multiple pre-designed components from which you easily approach and attach to your application, enabling an attractive, easy-to-use, and visually engaging design and rapid implementation.

Material Design. Material Design is a well-thought-out design system that describes the value and use cases of components. With Material Design, for example, you can use the Material Icons, meaning choosing icons that match your design system.

Adjustable theme. MUI provides simple installation and adjustment themes to use and globally implement for all components available to you, making it a highly functional and dynamic experience. By doing so, the theme color of the component, information about the palette, and surface properties, and some other styles can be customized, meaning that all your components can be consistent.

Well-structured documentation. MUI has clearly understandable and well-structured documentation, which includes guides with code examples to practice with.

Widespread support. MUI has great support for fixing bugs and issues, due to its constantly updatable library. In small releases, for all issues found, the team provides fixes. And as a user, you can participate in influencing what additions to the library will be added in the future. The team sends a feedback survey to all library developers every year in order to fix any issues and make the Material UI more usable, also you can tweet them feedback on the official account: @MaterialUI.

Community. Here you can find basic links with support and examples of using the MUI.

Who uses Material UI and its integrations?

Node.js, React, Next.js, Emotion, and etc, represent some of the most popular tools that are integrated with Material-UI. About 214 companies use Material UI in their technology stacks, here are some of them:

UNIQLO
Medium
Scale
Frontend
Google
SkyQuest Tech Stack

How to create your Material UI React application using the Flatlogic Platform

There are two ways to build your application on the Flatlogic Platform:

Create a simple and clear frontend application, generated by the CLI framework,

Build a CRUD application with frontend+backend+database.

Creating your CRUD application with Flatlogic

Step 1. Choosing the Tech Stack

In this step, you’re setting the name of your application and choosing the stack: Frontend, Backend, and Database.

Step 2. Choosing the Starter Template

In this step, you’re choosing the design of the web app. Here you can find the Material Template for your application.

Step 3. Schema Editor

In this part you will need to know which application you want to build, that is, CRM or E-commerce, also in this part you build a database schema i.e. tables and relationships between them.

If you are not familiar with database design and it is difficult for you to understand what tables are, we have prepared several ready-made example schemas of real-world apps that you can build your app upon modification:

E-commerce app;
Time tracking app;
Books store;
Chat (messaging) app;
Blog.

Afterwards, you can deploy your application and in a few minutes, you will get a fully functional CMS for your React Application with Material Design.

What is PHP?

Posted on February 12, 2022May 21, 2023 by Mark Feehily0

Introduction: What is PHP

PHP (an acronym for Hypertext Pre-processor or the previous one Personal Home Pages) is a server-side open-source scripting language. It is great for dynamic content management, session tracking, databases, and has fantastic community support.

PHP is a weak dynamic typing language, meaning it auto determines a lot of implicit conversions, even though there may be a lack of precision or equivocal conversions. In 2020 PHP 8 came out. It has a JIT (just-in-time) Compilation, which sped up the work of the Preprocessor multiple times.

PHP is a popular programming language and is the foundation of such CMSs as WordPress (powers 43% of all the websites on the Internet), DRUPAL, Joomla, and the most popular E-Commerce Magento 2. Also, there are very popular PHP-based MVC Frameworks Symfony such as Yii2 (very popular in Russia) and Laravel (takes the 1st place in GitHub RANKING).

How PHP works

Let’s elaborate how the Hypertext Preprocessor works. The browser sends an HTTP request to a web server. Then the index.php file is generated, which is handled by the preprocessor. Finally, the web server receives the output and sends it back over the Internet to a user’s web browser.

Why use PHP

PHP is incredibly easy for beginners and provides multiple advanced features for professional programmers. With it, you can learn and start writing basic scripts in a short period. Here is the list of the best features:

Versatility

PHP is a server-side programming language. Therefore, you need to set up a server to work with it. This language is also platform-independent. You don’t need a specific operating system to use it because it works on any platform, whether it’s macOS, Windows, Linux. For that reason, this is why it may be deployed on various systems and platforms easily and inexpensively.

Secure and swift

PHP used to be scolded for its ability to attack the site with SQL injection, but with the release of MVC frameworks, this is now impossible. The major advantage is that due to the wide distribution and support of the community, there are now multiple tools, frameworks, and security and cyberattack protection solutions available. The second equally major feature is speed, try to use versions 8 and up, as these versions introduced the JIT Compilation, which speeds up PHP.

Well-linked with databases

PHP provides an easy way to establish a reliable connection to almost any database. So it can instantly connect to MySQL, PostgreSQL, MongoDB, or any other database.

Testing

Among programming languages, PHP has a reputation for being stable and reliable. Its code has been tested under a wide variety of real-world and experimental conditions. If there’s a possible error or shortcoming, chances are someone in the community has found a way to deal with it. There are numerous frameworks and toolkits which are helpful for secure, efficiency and effectiveness of web development.

Community

PHP has a very responsive online community. The official documentation contains feature guides, chats and forums, so you can quickly solve your problem if you get stuck.

Low-cost open-source software

PHP is a no-cost language that can significantly help you save on your development expenses. A lot of the development tools normally used with this language are open-source and available for free, so they keep the cost of the project down even more. Numerous frameworks offer Hypertext functionalities and make the development process easier and much better, for example, the most popular and widely used is Laravel.

Conclusion

Rasmus Lerdorf is a Danish-Canadian programmer who released the first version of PHP in 1994. It continues to be a widely used and actual language in web development. It has been available for quite a long time. Major companies like Slack, Meta (Facebook), HPVM, and Wikipedia use the language extensively. Web Hosting Platforms like BlueHost, Site ground run their hosting servers using Hypertext Preprocessor.

On the Flatlogic Platform, you can also use PHP when choosing the Laravel backend framework for creating your application. Afterward, you will get in a few minutes the Laravel CRUD admin panel with DataBase models and API.

The post What is PHP? appeared first on Flatlogic Blog.

Is Frontend Development Easier Than Backend?​​