(Redirected from Tailwind)

A tailwind is a wind that blows in the direction of travel of an object, while a headwind blows against the direction of travel. A tailwind increases the object's speed and reduces the time required to reach its destination, while a headwind has the opposite effect.

Best Free Tailwind CSS Templates 2021. Best Free Tailwind CSS Web Templates, Landing Pages and Snippets for Your Next Web Projects. From landing pages presentation to login areas, you can easily customise and built your pages. Beautiful Example Pages. Tailwind Starter Kit is a completly new product built using our past experience in web templates. Take the examples we made for you and start playing with them. Tailwind CSS is a modern framework to create styles for your website including your landing pages. It could be a Bootstrap alternative for styling your website in 2021. Tailwind itself is open source and free. You can find the code source on GitHub and you could also contribute to the project. Free open source Tailwind CSS starter template (Hero Product) to use with node.js/npm, postcss+purgecss! Tailwind Toolbox - Free Starter Templates and Components for Tailwind CSS Free open source Tailwind CSS starter Templates and Components to get you started quickly to creating websites in Tailwind CSS! Landing page templates for startups. Beautifully designed HTML, React, Vue.js, and Tailwind templates! Save weeks of time and build your startup landing page in minutes.

In aeronautics, a headwind is favorable in takeoffs and landings because an airfoil moving into a headwind is capable of generating greater lift than the same airfoil moving through tranquil air, or with a tailwind, at equal ground speed. As a result, aviators and air traffic controllers commonly choose to take off or land in the direction of a runway that will provide a headwind. However while on take-off and landing, headwinds are good because they allow you to use a shorter runway, in flight, headwinds are bad because they slow you down and require that you use more fuel to get to your destination. Conversely, tailwinds are bad on take-off and landing, but are good in flight.

In sailing, a headwind may make forward movement difficult, and necessitate tacking into the wind.

These two terms are accordingly used in business/finance.

Tailwinds and headwinds are commonly measured in relation to the speed of vehicles — commonly air and watercraft — as well as in running events — particularly sprints.

## Aeronautics calculations

Pilots calculate the Headwind or Tailwind Component and the Crosswind Component of local wind before takeoff. The direction of wind at a runway is measured using a windsock and the speed by an anemometer, often mounted on the same post. Headwind and Tailwind are opposite interpretations of the wind component which is parallel to the direction of travel,[1] while Crosswind represents the perpendicular component. Determining the ground speed of an aircraft requires the calculation of the head or tailwind.

Assume:[2]

${displaystyle A={text{Angle of the wind origin from the direction of travel}}}$

${displaystyle WS={text{The measured total wind speed}}}$

${displaystyle CW={text{Crosswind}}}$

${displaystyle TW={text{Tailwind}}}$

${displaystyle HW={text{Headwind}}}$

Then

${displaystyle CW=sin(A)cdot WS}$

${displaystyle HW=cos(A)cdot WS}$

For example, if the wind is at 09015 that means the wind is currently from heading 090 degrees with a speed of 15 Knots and the aircraft is taking-off from runway 24; having heading of 240. The pilot prefers the runway side with less than 90 difference from wind direction, in this case Runway 06; heading 060. Here, ${displaystyle A=30^{circ }}$.

${displaystyle {text{Crosswind}}=sin[30^{circ }]cdot 15{mathsf {knots}}approx 7.5{mathsf {knots}}}$

${displaystyle {text{Headwind}}=cos[30^{circ }]cdot 15{mathsf {knots}}approx 13{mathsf {knots}}}$

The aircraft is said to have 7.5 knots of crosswind and 13 knots of headwind on runway 06, or 13 knots of tailwind on runway 24.

Aircraft usually have maximum tailwind and crosswind components which they cannot exceed. If the wind is at eighty degrees or above it is said to be full-cross. If the wind exceeds 100 degrees it is common practice to takeoff and land from the opposite end of the runway, it has a heading of 060 in the above-mentioned example.

## References

1. ^'headwind', dictionary.com, 2016
2. ^'Crosswind and Headwind calculation - IVAO - International Virtual Aviation Organisation'. mediawiki.ivao.aero. Retrieved 2019-11-03.
October 15, 2020

One of the constant requests I have as a freelancer programmer is constructing a landing page for a project/company/research project. Therefore, it is better to have an already starter template adopted as a base to iterate upon it quickly.My starter (https://github.com/wittyprogramming/tailwindcss-alpinejs-starter), is an opinionated template that has the following features:

• Tailwind CSS for styling
• Alpine.js for template/dynamic logic
• a simple build system that may help me scale up if the needs arise (for example, add scss for styles or Typescript)

Tailwind CSS is a highly customizable, low-level CSS framework gaining popularity lately. It is not opinionated as it gives you the building blocks for styling your components.

Unfortunately, tailwind requires a build system to take advantage of all its features. Furthermore, during deployment, the unused CSS must be removed because the style file becomes very large (>2Mb). The PostCSS and its plugins come to the rescue.

Alpine.js is very similar to tailwind but for the javascript. It provides the features of Vue.js with a much lower cost and - I think - a most suitable replacement for jQuery than other frameworks. If the code requirements are very light, then a build system is not required. Just add the Alpine.js package in a script tag and sprinkle your login in the HTML DOM file.

I must say that Alpine.js, which does not use a virtual DOM, has some tricked spots regarding the scope of nested components and their communication or the way nested loops are constructed, but for most cases - e.g., landing pages - is adequate. For more information, checkout out my post introducing Alpine.js.

My preference is to use Typescript (I love the IntelliSense capabilities that provide); therefore, I use the Evan Wallace’s esbuild, a fast Javascript/Typescript bundler, and a minifier.

Finally, we will use the gorgeous, simple, and versatile landing page design from the Creative Tim’s Tailwind Starter Kit for our starter template’s design. It way better for our productivity to have a well-formed, responsive design as a base.

## Template initialization

Let’s initialize our starter:

The structure of the template is straightforward:

• `src/css/` folder contains our template’s source styles with the file `main.css` as the entry point.
• `src/ts/` folder contains our typescript code with the file `main.ts` as the entry point.

The `assets/` folder contains the static assets - img, files to downloads, etc. Here, the output files from the CSS (CSS and web fonts) and js (js file) build system will be created.

Let’s begin by getting the `landing.html` and the Landing Page starter kit’s assets folder. We don’t need the `vendor` directory (contains fontawesome icons) as we will self-hosted it ourselves.

Then, install the required packages:

## PostCSS configuration

It is time to create a build system for the styles based on PostCSS, a modern plugin-based CSS parser. The `src/css/` folder contains our source CSS, which builds a minified clean version in the file `assets/style.css`.

## Tailwind Layouts

Next, install the dev dependencies:

• `postcss` packages,
• its cli version,
• and the plugins:
• `postcss-import` for using the import function in CSS,
• `@fullhuman/postcss-purgecss` for the purgings of the unused CSS styles,
• `postcss-copy` for copying assets referenced as web fonts , and, of course,
• the `cssnano` package for the minification.

Our `postcss.config.js` is:

The postcss.config.js format is straightforward. We define our plugins, and when we initiate the deployment build by using an environmental variable, we use the purge CSS and minification plugins.

The `package.json` build scripts are:

The `cross-env` is an npm package that sets environment variables in a cross-platform away.

## esbuild configuration

Next step, the `esbuild` is added. Unfortunately, the `esbuild` does not have a watch function in its cli utility (see this issue). No worries, the chokidar-cli is an excellent cross-platform command-line utility to watch file system changes.

– UPDATE 14 Feb 2021 –

The above is not valid anymore. After version v0.8.38, the esbuild added a `-watch` flag that makes the `chokidar-cli` package unnecessary. Moreover, after the v0.8.45, the esbuild added the `--servedir=` flag, allowing running a built-in web development server. The rest directions reflect that change. If you prefer the previous configuration with the `chokidar-cli` package, please refer to a previous commit in the GitHub repository

I like to use Typescript, as the IntelliSense that provides is impressive and very helpful. I understand that Typescript is not everyone’s favorite, and it may complicate some things unnecessary. Hence, the following step is not required, but to acquire the Typescript’s Intellisense superpower, install the `typescript` packages and initialize a `tsconfig.js` in the `src/ts` folder.

And in the `src/ts` folder run the following command to initialize the `tsconfig.js` file.

In `main.ts,` import the `alpine.js`.

## Tailwind Template Landing Pages

The package scripts are very straightforward:

The `watch-js` command watches for any changes and creates a debug build of our code with a source map. The `debug-js` command is the same as the `watch-js` command, but it runs the esbuild built-in web development server. The `build-js` command executes our deployment pipeline and outputs the minified code.

To run both commands, will use the concurrently npm package:

and add the stript:

Finally, the deployment command runs the `build-js` and `build-css` commands and copy the `index.html` and `assets` folder to a `dist` folder using the `copyfiles` package. This `dist` folder is the deployment folder.

Therefore, during the development (for the watch mode) use:

## Tailwind Css Starter Template

If you want a web development server alongside use :

For deployment, run:

## Starter Github Repository

You can use the provided starter template freely at https://github.com/wittyprogramming/tailwindcss-alpinejs-starter

Share: