diff --git a/src/config.toml b/src/config.toml index 5c8c7be..7099a58 100644 --- a/src/config.toml +++ b/src/config.toml @@ -15,3 +15,7 @@ title = 'Equitable Open-Source for Web3' [security] [security.exec] allow = ['^go$', '^postcss$', '^npx$', '^babel$'] + +[taxonomies] + category = "categories" + tags = "tags" diff --git a/src/content/blog/_index.md b/src/content/blog/_index.md new file mode 100644 index 0000000..8de83c4 --- /dev/null +++ b/src/content/blog/_index.md @@ -0,0 +1,7 @@ +--- +title: "blog" +description: "All things open-source." +date: 2023-03-27 +menu: "main" +weight: 5 +--- diff --git a/src/content/blog/adding-some-flavor-to-your-cup-of-tea.md b/src/content/blog/adding-some-flavor-to-your-cup-of-tea.md new file mode 100644 index 0000000..1a76294 --- /dev/null +++ b/src/content/blog/adding-some-flavor-to-your-cup-of-tea.md @@ -0,0 +1,29 @@ +--- +title: "Adding Some Flavor to Your Cup of tea" +date: 2023-05-02 +categories: [gui, package management] +tags: [homebrew, gui, package management] +draft: false +featured_image: "/Images/blog/add-some-flavor.jpg" +--- +_A year ago, we brewed the first cup of tea. Now, it’s time to add some honey to the mix._ + +Introducing [tea’s Graphical User Interface (GUI)](https://www.producthunt.com/products/tea) — the latest addition to the revolutionary tea package management system developed by the creator of Homebrew. The tea GUI is set to change the way developers approach package management by making it more accessible, secure, and intuitive. + +Package managers are the backbone of every tech stack, yet they haven’t evolved in decades. tea is here to change that. With the introduction of the tea GUI, developers can now visually browse a package manager through a front-end, and install packages without navigating the CLI. They will soon be able to review packages for the first time, as well. Developers can also brand their creations through the tea GUI, adding to their packages’ visibility. + +**So what is tea, and why is the tea GUI necessary?** Tea is a next-generation package manager that provides developers with intuitive solutions to optimize their output while saving them time and effort. Tea automatically identifies and changes the versions necessary for different projects, cutting down on manual input previously required from developers. Furthermore, tea automatically manages dependencies, removing burdensome mapping requirements from contributors. + +![](https://miro.medium.com/v2/resize:fit:1400/1*aaEevilbfR8SLyfJVZqbRQ.jpeg) + +The tea GUI is necessary for two main reasons: _security_ and _user experience_. There are many security vulnerabilities when installing and running new packages due to a lack of infrastructure around the building and maintenance of open-source software. For example, a newer package might not have been sufficiently tested, and it might make whatever is built on top of it vulnerable to malicious attacks. With the tea GUI, users can test and review packages, ensuring that they can trust the packages they are installing into their computers. + +![](https://miro.medium.com/v2/resize:fit:1400/1*j13M0DLkCi30mGTpB2MKgA.jpeg) + +Experienced developers may be familiar with installing dependencies, changing versions, and dealing with prerequisites for building software. However, those who don’t code regularly may find these requirements complex and difficult to navigate, which can make the development process less equitable (and pleasant). With the tea GUI, the complexities of package management are significantly decreased, making it more accessible to developers of all skill levels. + +![](https://miro.medium.com/v2/resize:fit:1400/1*74epoL7ePXz8FtuHEaGP8Q.jpeg) + +The tea GUI is set to revolutionize the way developers approach package management. From the creator of Homebrew, tea is bringing a new horizon to open-source development: one that is equitable, intuitive, and magical. Add some flavor to your cup of tea and try out the tea GUI today. + +Check out tea on [Product Hunt](https://www.producthunt.com/posts/tea) to leave us a review, and connect with our team on [Twitter](https://twitter.com/teaxyz) and [Discord](https://discord.gg/tea-906608167901876256)! Download the [tea CLI](https://tea.xyz/) directly from our website. diff --git a/src/content/blog/dev_diary-finding-the-fun.md b/src/content/blog/dev_diary-finding-the-fun.md new file mode 100644 index 0000000..c2b78db --- /dev/null +++ b/src/content/blog/dev_diary-finding-the-fun.md @@ -0,0 +1,57 @@ +--- +title: "dev.diary—Finding the Fun" +date: 2023-01-23 +categories: [dev.diaries, open-source] +tags: [open-source, homebrew, programming] +draft: false +featured_image: "/Images/blog/finding-the-fun.jpg" +--- +When building any kind of product it takes a little time before you figure out its shape. Famous games developer Sid Meier described this process as “finding the fun”. He would iterate compulsively on his ideas until those little changes in the little details would uncover something sufficiently new and engaging that he had the basis for a new game. + +![](https://miro.medium.com/v2/resize:fit:1024/1*Y25rtCmwlRMmcRlef-mlFA.png) + +This is the approach I take with my products. From my childhood writing toys in BBC Basic, to working on the amaroK music player for KDE in the early 2000s, to making the Android version of TweetDeck in 2010, to how I approached making Homebrew and now with its spiritual successor: `tea`. + +We released [tea/cli](https://github.com/teaxyz/cli) a couple months ago. At that point I felt the product was “ready enough” for general consumption. We had a number of compelling features coupled with a good mission statement and together to me that seemed enough to present it to the community and start gathering wider ideas and interest. + +Which is a key differentiator between developing most products and developing open source: you bring your userbase in **_before_** you’ve “found the fun”. + +Before launch I jokingly would say that _tea was not a package manager_. I was being flippant. But also I wasn't being flippant. Package Managers as a class of tool haven’t evolved since their inception in the 90s. They are very much in the what I call “egotistical tool” category: that being: you \*_will_\* learn how it works thank you very much because the package manager is a **very important tool** and you are lucky to have it. I’ve not a fan of this attitude. + +I believe tools are a special class of utility. A well written tool completely eradicates entire classes of tedium enabling its users to reach new heights in productivity. A well written tool enables functionality that before was either too tricky to accomplish or completely impossible. + +At launch we said `tea` was a universal interpreter, a universal environment manager, a unified dependency manager and it could run executable markdown. + +[Changelog rightly called me out on this](https://changelog.com/news/491E), saying “might Max and the team be thinking _too_ big this time around?” + +The truth is we hadn’t yet _quite_ found the fun. + +Two months of passionate early adopter usage later and a few things were becoming apparent. tea’s real super powers were the underlying rethinking about the nature of package management, specifically that with tea the package manager disappeared. So I decided to experiment with doubling down on that. + +At launch you could type `tea -X npm start`and tea would look for `npm` and run `start` , but if it didn’t find `npm` it would fetch it first. This was in fact a very near launch addition by me but it was a truly wonderful reduction in friction for using the open source ecosystem. And fundamentally what this feature said was: **the package manager needs to get out the way.** + +> tea doesn’t _install packages_—at least not in a conventional sense. In the above example `npm` is not available unless you type `tea -X npm` otherwise it is “stowed” in `~/.tea` . This is important since I want using tea to complement your system. tea is not an operating system, it is a complement to whatever system (Mac, Linux, Windows, etc.) you are using. + +Soon after a passionate early adopter of tea suggested that symlinks to tea should behave as though `tea -X foo bar` was called. So we implemented that and immediately it was apparent that this was a seriously cool feature. I used this to create a symlink from `tea` to `bpb` (a tool that makes signing your git commits _trivially easy_) and immediately knew that forever more I would not have to piss about for an hour getting my git-signing set up whenever it stopped working or a had to set myself up on a new machine, remote server or when clean installing my OS. + +A developer at tea realized that you could make the shell’s command-not-found handler call `tea -X` . Command not found handlers have been used by the package manager before. For example, Ubuntu uses it to suggest packages that may satisfy whatever you typed. The idea made me laugh because it seemed so ill-advised! But we added it to the `README` as a hack that users may want to try out—_for fun_. + +But I got to wondering… _had we in fact_ **_found the fun_**? I decided to add the command-not-found handler to my shell and see how I liked it. + +After a few days I stopped laughing. I started getting excited. This hack wasn’t a hack. _It was awesome_. It completely delivered on tea’s promise and significantly simplified our narrative. + +How do you use tea? You don’t. You use the tools that the open source ecosystem provides. If you read a blog post about a new tool then just type the commands you read into your Terminal and try it out. There’s no “figure out the package name and then install it step”. There’s no “will installing this break other stuff on my system” concerns. If you don’t like it then don’t worry about it—it’s already gone. + +``` +# want to see if bun will run your node project?$ bun run starttea: stowing bun^0.4bun: start$ which bunbun not found# ^^ it’s not in your PATH!$ bun --version0.4.0# ^^ but tea surfaces it for you +``` + +tea still is a “universal interpreter” but that just falls under the general banner; we don’t have to explicitly name this feature; tea just knows how to make what you throw at it work. Be that a command or a script, tea makes it possible for you to get on with what matters: making your app. + +And so I dropped executable markdown completely. Part of the reason I added exe/md was the desire for tea to be a tool that makes development a dream. And we have achieved this because now if you want to use executable markdown to run the script `build` you just type `xc build` and tea installs [xc](https://github.com/joerdav/xc) transparently. Whatever “task runner” your project needs is transparently available. Having this feature in tea itself no longer made sense. + +When it comes to making great products you need to be able to drop entire features without ego or the sunk-cost fallacy holding you back. What matters is the entire product vision no matter how cool you think something is. I still think exe/md is a cool idea, and didn’t know about `xc` before writing it. I’m very glad someone else thought the same and built it. UNIX tools should do one thing and one thing well. + +**tea 0.19** lives up to the UNIX philosophy and thanks to Changelog for reminding me about that. I revisited every part of the CLI and retooled it towards this purpose. Check out the new README for the deets, the caveats and what comes next: + +[https://github.com/teaxyz/cli](https://github.com/teaxyz/cli) diff --git a/src/content/blog/dev_diary-tea-is-env++.md b/src/content/blog/dev_diary-tea-is-env++.md new file mode 100644 index 0000000..96e4ad7 --- /dev/null +++ b/src/content/blog/dev_diary-tea-is-env++.md @@ -0,0 +1,98 @@ +--- +title: "dev.diary—tea is env++" +date: 2023-01-31 +categories: [dev.diaries, programming] +draft: false +featured_image: "/Images/blog/tea-is-env.jpg" +--- +A few aspects of the shape of tea’s CLI have been bothering me. + +While building out the pre-release tea began to take shape as a “universal interpreter”. I have long thought package managers were depressingly basic in operation, a strange thing for such a (potentially) powerful part of the stack. It seemed somehow backwards that if I obtain a script, I first must figure out what package runs it, and then possibly even install a bunch of dependencies in order for it to run. Why can’t the package manager figure this stuff out for you? And thus `tea script.ext` did just that. + +![](https://miro.medium.com/v2/resize:fit:1000/1*7F_695_rMJ8JNn7Sa_pR9g.jpeg) + +want [https://charm.sh](https://charm.sh/)’s amazing vhs terminal recorder? Just type \`vhs\` + +While iterating around this I realized that it wasn’t laziness that was holding me back from implementing `tea install` , it was a desire to find something _better;_ a better paradigm for using open source; a better paradigm than _managing it_. So I held off. My coworkers complained that they still needed `brew` even though we were building its spiritual successor. + +Yet I held off because I know that if I make parts of my workflow tedious, I will come up with a solution. I suffer a little now to reap the rewards later. + +I would joke with people that “tea wasn’t a package manager”. This was tongue in cheek—of course tea was and is a package manager. But it didn’t seem much like one. I wanted people to stop thinking about the package manager altogether. I wanted to make something where managing packages stops being a part of your workflow at all. You have apps to build, and I want you to build them with tools like mine getting out of your way entirely. + +In pursuit of being a universal interpreter without installing packages one must build environments that create a kind of container for the software. It seemed useful to make those environments available more generally. + +With `tea` you build an environment by _adding packages_ with `+pkg.com` syntax. With the environment assembled you then execute a command. Plus package syntax was a wonderful discovery allowing entirely new categories of workflows. + +What was tea? It seemed to have become a tool for assembling environments of open source software which you then apply to other tooling. If we can figure out those environments for you, we do, if we cannot we need you to tell us. + +_tea was a_ _universal interpreter_. So I looked to other interpreters to see if the similarities should go further. + +It’s typical with interpreters for just typing them to start a REPL (a [read eval print loop](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop)). You exchange your Bash prompt for a Python, Ruby, etc. prompt. Should tea do this? We tried it, so `tea +deno.land` would start a new shell with `deno` available. It was somewhat a good feature and it was idiomatic with the concept that tea was a kind of interpreter. + +But something about it irked me. + +tea described itself as a unified package manager, a universal interpreter, a universal environment manager. It was all these things, but you can’t sell a product if you can’t put your finger on what the product _\*is\*_. + +[Last week](https://medium.com/teaxyz/dev-diary-finding-the-fun-1b351431fcac) I talked about how we resolved the messaging by more clearly seeing what tea was. tea is a magical package manager, it’s _invisible and powerful_. Stop thinking about installing stuff—get on with your work instead. If you don’t need to even think about managing packages entirely you can use new tools and workflows effortlessly, but also other people who make tools, scripts or workflows can know you, the end user for their efforts, have the entire open source ecosystem at your fingertips too. They don’t need to tell you how to install a bunch of stuff, with a bunch of different versions, for a bunch of different platforms in their README—you have tea. + +This week I realized that during the history of UNIX there was another innovation in this area. As developers for UNIX like systems exploded, new tools began to appear all over. Each UNIX had different conventions and preferences for where such tools may be installed. This would be problematic for the **_shebang_**. + +## Shebangs + +Perl was one of the first interpreted languages. It grabbed the minds of all UNIX users since it was fast to dev like shell scripting but powerful like “proper” languages (eg. C). It supported being “shebanged”, the `#!` at the front of a text file that told your shell who interprets the file you want it to run: + +``` +#!/usr/bin/perl +``` + +The problem is: perl was new and not POSIX with an associated “this is where it should be installed” path. It might be installed anywhere! Shebangs were not designed to search `PATH` (for security reasons presumably) but this impeded the possibility of distributing a perl script to other communities. + +So`/usr/bin/env` was built. It was designed to construct environments† and then execute commands inside those environments searching the specified `PATH` for the command to run. POSIX declared its path to be `/usr/bin/env` so now shebangs could be: + +``` +#!/usr/bin/env perl +``` + +Thus alleviating the location problem. + +However the user still needed to install `perl` themselves. + +> † though not commonly used `env FOO=bar baz` and other environment management features are a primary part of `env`’s CLI. + +## tea is env++ + +``` +#!/usr/bin/env -S tea perl## see `man env` to understand the `-S` +``` + +Like `env` we construct an environment for `perl` and run it, but as supplemental functionality we install `perl` and its dependencies first. + +One day perhaps we’ll be POSIX and we can reduce this to: + +``` +#!/usr/bin/tea perl +``` + +One can only dream… + +## Adapting tea/cli Based on this Realization + +tea is a more capable `env`. Should this be something we document? Should this adapt how we introduce it and talk about it? I began exploring that. + +Firstly, our REPL like feature `tea +rust-lang.org` starts a new shell that contains the environment for rust. Should instead we output the environment like `env` does? + +I tried it and it felt right. We already use this functionality for tea’s magic, so now instead of that being a special mode it was a idiomatic use of `tea` as a CLI. + +However the REPL functionality is neat, so do we really dare lose it? + +Fortuantely an idiomatic way to do the REPL presented itself to me, simply append `sh`, eg. `tea +rust-lang.org sh`. This is all our REPL was doing underneath anyway. Now tea doesn’t have any special modes, we are communicating to the user intuitively that tea installs packages, creates environments and executes commands within them. To see the environment that will be created, stop typing (eg `tea +rust-lang.org`). To use the environment, add commands. + +Typing `tea` by itself dumps the current supplemented environment. If you have our magic installed then inside a developer environment you can see what tea did to create that environment. + +I’m super happy with these changes as now I feel tea is close to being very well scoped, intuitive to understand, composable, flexible and useful to many different tasks along the lines of its utility proposition. _We are both more powerful than all other package managers while also being more intuitive._ + +I foresee a v1 in the near future. + +## Breaking Change + +This is a breaking change, but we are pre v1. After v1 we will not break the CLI API unless we bump the major version. diff --git a/src/content/blog/something-new-is-brewing.md b/src/content/blog/something-new-is-brewing.md new file mode 100644 index 0000000..0f1cd86 --- /dev/null +++ b/src/content/blog/something-new-is-brewing.md @@ -0,0 +1,91 @@ +--- +title: "Something New is Brewing" +date: 2022-03-23 +categories: [open-source, programming] +tags: [programming, homebrew, install tea] +draft: false +featured_image: "/Images/blog/something-new-is-brewing.jpg" +--- +I created Homebrew nearly 13 years ago out of sheer necessity. I found the tooling available to developers at the time haphazard and difficult to tease into shape. After complaining about it at the pub one evening, I was met with an exasperated “Max, quit whining and do something about it”. So I did. (Thanks Jono). + +From the start, I designed it to be delightful where other tools were not. I have always firmly believed when building anything, especially open source, that the tooling should get out of your way because you have much more important work to be doing. + +I also intentionally designed it to _go viral_. I was lazy, you see, in the way all the best developers are. I needed you — _all of you_ — to help me build it. I did this so well that Homebrew became one of the biggest open source projects of all time. + +Not long after starting, I quit my job to work on this project I felt I was put on the world to make. However… within a few months, the task was long from complete, and I found myself skint. I still remember going to the bank and asking what would happen if I overdrew the next day to pay for rent. They didn’t care much. + +Thus began a steady rotation between jobs and open source. I wanted to work on open source full time, believing it would help the world become a better place. But that remained an elusive dream. + +Eventually I burned out and quit maintaining Homebrew. I handed the reins to the community that had emerged from the trail I had laid out. I’m proud to say the project has done very well without me. + +A few times a year someone would ask me if I would make a brew2. I always said no. What would be the point? brew is good, and I’m not going to reinvent the wheel. + +## A Wild Timothy Appears + +I met Timothy in Chicago in late 2013. We clicked and worked together on many projects. We were both passionate about what people can build in open environments that encourage and incentivize contribution. Eventually I moved away but the friendship stuck. Timothy caught the wave of crypto while I moved on to become a top mobile developer. + +Every year or so he’d hit me up and talk to me about what was new in crypto, trying to get me to bite. I always declined. I admired the bitcoin white paper but I felt crypto was just money and, for me, money was the least interesting consequence of work. + +## A Change of Heart + +My partner and I were trying for a baby last year and in September, she showed me the positive test. We were overjoyed, but the next morning I woke up in a cold sweat. How was I going to provide for my family? _Open source was not paying the bills._ + +I went back over all my old ideas looking for a startup idea I could turn into a business. Eventually I came back to my ream of notes about “brew2”. Despite previously snubbing the idea of making another, I am an obsessive note taker and had been recording my thoughts as they came to me for years. + +I moved on, at the time still convinced open source could not pay the bills. + +Timothy phoned me to catch up and once more pointed me to what he was now calling “web3”. + +I sniffed around the top of the rabbit hole. + +While learning about web3 I bought and sold a few NFTs. The process was mostly uninteresting except for when I sold one and saw the automated, unavoidable 10% royalty enforced by a digital contract (with no need for a legal structure) that compensated the original creator for secondary sales_._ I felt the sting of inspiration. + +_web3 enables indirect compensation._ + +I wondered if we could apply this concept to helping distribute value to open source. + +I dove down the rabbit hole. + +## The Nebraska Problem + +It’s a well-known problem. Developers make fundamental improvements to the nature of the Internet. Their contributions are grabbed by the community with both hands and inserted into the tower: + +![](https://miro.medium.com/v2/resize:fit:770/0*TTqemZPUKyxK8mgo) + +[https://xkcd.com/2347/](https://xkcd.com/2347/) + +Once a block is placed it’s rarely removed. The maintainers become charitable volunteers. + +Solutions like sponsorship and bounties exist. Both unfortunately reward only the top of the tower, the visible packages. Beneath them lie tens of thousands of vital packages that most people don’t even know exist. + +Recently Log4J [hit the news](https://www.cnet.com/news/privacy/log4j-software-bug-cisa-issues-emergency-directive-to-federal-agencies/) with a zero day that impacted most of the Internet. They fixed the bug and endured abuse while pointing out that they receive no funding from the myriad of unicorns that use them. They probably still don’t. Most of these hyper profitable corporations didn’t even know that Log4J was a vital brick in their tower of open source built by people they don’t even know and have never even paid. + +CoreJS is another famous example, downloaded 30 million times a week. Their [README](https://github.com/zloirock/core-js/blob/master/README.md) is depressingly laced with _genuine need_ for funding to help them keep every Node.js application that exists afloat. + +## Let’s Brew a Fresh Pot + +Tools like Homebrew lie beneath all development tools, assisting developers to actually get development done. We know the graph of all open source, which means we’re uniquely placed to innovate in interesting and exciting ways. This is exactly what [tea](https://tea.xyz/) will do. We’re taking our knowledge of how to make development more efficient and throwing innovations nobody has ever really considered before. Package managers haven’t been sexy. Until now. + +Most importantly, we’re moving the package registry on-chain (relax, we’ll use a low-energy proof of stake chain). This has numerous benefits due to the inherent benefits of blockchain technology: + +- Packages will be immutable (no more [left-pad incidents](https://www.theregister.com/2016/03/23/npm_left_pad_chaos/)) +- Packages will always be available (we’ll use decentralized storage) +- Releases will be signed by the maintainers themselves (rather than a middleman you are told you can trust) +- Tools can be built to fundamentally verify the integrity of your app’s open source constitution +- Token can flow through the graph + +Token flowing is where things get _really_ interesting, but first let’s set things straight: we’re not changing the nature of open source. It’s still free. web3 has enabled novel new ways to distribute value, and with our system people who care about the health of the open source ecosystem buy some token and stake it. Periodically, we reward this staking because it is securing our token network. We give a portion of these rewards to the staker and a portion to packages of their choice _along with all the dependencies of those packages_. + +Note that no portion goes to _us_. We’re not like the other app stores. + +## What is tea? + +Founded by Max Howell, the creator of Homebrew and Timothy Lewis, famous web3 evangelist: + +**tea** is a delightful product suite that you will adore. + +**tea** is the home to a DAO that will ensure the open source maintainers that keep the Internet running are rewarded as they deserve. + +**tea** is our revolution against a failing system. + +Stay in touch: [https://tea.xyz](https://tea.xyz/) & [https://linktr.ee/teaxyz](https://linktr.ee/teaxyz) diff --git a/src/content/categories/_index.md b/src/content/categories/_index.md new file mode 100644 index 0000000..c59a39d --- /dev/null +++ b/src/content/categories/_index.md @@ -0,0 +1,3 @@ +--- +title: Categories +--- diff --git a/src/content/tags/_index.md b/src/content/tags/_index.md new file mode 100644 index 0000000..56d2e29 --- /dev/null +++ b/src/content/tags/_index.md @@ -0,0 +1,3 @@ +--- +title: Tags +--- diff --git a/src/layouts/_default/list.html b/src/layouts/_default/list.html index e69de29..948689f 100644 --- a/src/layouts/_default/list.html +++ b/src/layouts/_default/list.html @@ -0,0 +1,150 @@ + + + +{{ partial "head.html" . }} +{{ partial "header.html" . }} + + + +{{ partial "navbar.html" . }} + +
+
+
+
+

{{ .Title }}

+

Welcome to the tea party. This is where we talk about everything from open-source to the future of AI and web3. Follow our dev.diary series to get insight from our brighest devs, and learn what they're doing to make the internet a better place.

+
+
+
+
+
+
+
+
+ {{ range .Pages }} +
+ +
+ {{ if .Params.featured_image }} +
+ {{ end }} +
+

{{ .Title }}

+ Published: {{ .Date.Format "02/01/2006" }}
+ Categories: {{ range .Params.categories }}{{ . }}, {{ end }} + {{ trim .Summary 5 | plainify }} +
+
+ +
+ {{ end }} +
+
+ + {{ partial "sidebar" . }} + +
+
+
+ + + + + + + diff --git a/src/layouts/_default/single.html b/src/layouts/_default/single.html index e69de29..95d8ca3 100644 --- a/src/layouts/_default/single.html +++ b/src/layouts/_default/single.html @@ -0,0 +1,99 @@ + + + + {{ partial "head.html" . }} + {{ partial "header.html" . }} + + + {{ partial "navbar.html" . }} +
+
+
+
+
+

{{ .Title }}

+

Published: {{ .Date.Format "02/01/2006" }}

+ {{ .Content }} + Back to blog +
+
+ + {{ partial "sidebar" . }} + + + +
+
+
+ + + + + diff --git a/src/layouts/_default/taxonomy/categories.html b/src/layouts/_default/taxonomy/categories.html new file mode 100644 index 0000000..e3bb24c --- /dev/null +++ b/src/layouts/_default/taxonomy/categories.html @@ -0,0 +1,8 @@ +

{{ .Page.Title }}

+ diff --git a/src/layouts/categories/single.html b/src/layouts/categories/single.html new file mode 100644 index 0000000..498b205 --- /dev/null +++ b/src/layouts/categories/single.html @@ -0,0 +1,24 @@ + + +{{ partial "head.html" . }} +{{ partial "header.html" . }} + +{{ partial "navbar.html" . }} +
+
+

Category: {{ .Title }}

+ +
+
+ + + diff --git a/src/layouts/partials/footer-content.html b/src/layouts/partials/footer-content.html index b22a916..646cbe3 100644 --- a/src/layouts/partials/footer-content.html +++ b/src/layouts/partials/footer-content.html @@ -26,10 +26,10 @@
Quick Links
- blog
- careers
- privacy policy
- terms of use
+ blog
+ careers
+ privacy policy
+ terms of use
Enter your email to join our newsletter:
@@ -46,7 +46,8 @@ diff --git a/src/static/Images/blog/add-some-flavor.jpg b/src/static/Images/blog/add-some-flavor.jpg new file mode 100644 index 0000000..13f3ef9 Binary files /dev/null and b/src/static/Images/blog/add-some-flavor.jpg differ diff --git a/src/static/Images/blog/finding-the-fun.jpg b/src/static/Images/blog/finding-the-fun.jpg new file mode 100644 index 0000000..a39d2e1 Binary files /dev/null and b/src/static/Images/blog/finding-the-fun.jpg differ diff --git a/src/static/Images/blog/something-new-is-brewing.jpg b/src/static/Images/blog/something-new-is-brewing.jpg new file mode 100644 index 0000000..aa51796 Binary files /dev/null and b/src/static/Images/blog/something-new-is-brewing.jpg differ diff --git a/src/static/Images/blog/tea-is-env.jpg b/src/static/Images/blog/tea-is-env.jpg new file mode 100644 index 0000000..6e2525e Binary files /dev/null and b/src/static/Images/blog/tea-is-env.jpg differ diff --git a/src/static/css/typography.css b/src/static/css/typography.css index 967fb18..ca91cab 100644 --- a/src/static/css/typography.css +++ b/src/static/css/typography.css @@ -105,7 +105,7 @@ a.nav-link:hover{ border-bottom: 1px solid #00ffd0; } -/* Breakpoint-Specific Typography */ +/* Breakpoint-Specific Typography @media only screen and (max-width: 576px) {