What are Reddit's favorite Static Site Generator Apps?
Next.js
Jekyll
Hugo
GitBook
Grav
Hexo
MkDocs
Hakyll
DocPad
Pelican
Yellow
Top Reddit reviews mentioning Static Site Generator Apps:
By reading this, you'll become an angr pro and will be able to fold binaries to your whim
If i understand what I've read correctly this is a tool for picking apart and experimenting with existing compiled binaries. My guess is to probe for exploits.
Hey there new players!
A while ago I wrote a csgo-guide that many people liked and got a 5-star rating. Being motivated by the feedback, I decided to keep on writing and now it has become a complete e-book for cs-players.
I would love to hear some feedback. I know it is very detailed/boring in the beginning, but the tips and tricks in chapter 4 are surely helpful for a lot of players :)
Here's the link: Ready to GO?
Keep on grinding! -n0tch2k
The tutorial I most often see getting suggested is TypeScript Deep Dive by Basarat Ali Syed. As a heads up, it may document bleeding edge stuff from our nightly builds, but this is usually not a problem.
Do you have any specific sorts of things you'd like to see in our current docs?
Jekyll is a static cms, meaning once you did the html template, you simply add pages with some header configuration to generate a blog.
Biggest upside IMHO is that you can host your blog for free on github pages.
It's a free cms, that comes with free hosting so you only might need a domain if you don't want a something.github domain. And it's pretty simple to develop locally and push to github when ready.
No actual coding required, only yaml configuration files.
Yeh I can relate, FWIW it does get easier with practice. But 100% agree that we’ve sort created as many problems as we’ve solved with modern JS.
there is a pushback happening with some newer frameworks like Astro.build trying to simplify things.
For React, if you haven’t tried Next.js, definitely give it a go, plenty of helpful documentation that could smooth things out for you.
I mostly agree. I've said that the 3 best parts of angular are typescript, the di system, and rxjs. And ngModules by themselves are a bit annoying but they do multiple jobs and once you understand what you can do with them they aren't a terrible solution to a complicated problem.
There are some solutions to the library paralysis problem of react like next.js and I believe Uber recently released their framework that uses react as the renderer. But angular is still ahead a bit here I think because it's all designed together rather than developed separately and just glued together.
Personally though I disagree about jsx. Some things, like dynamic component layouts, are much simpler with jsx and in general I think it just feels nice to use.
But with the flexibility jsx brings it also brings the ability to overcomplicate templates as you are pointing out. It's a valid criticism where the best answer I have is "learn to not do that". It's not like people don't also write terrible angular components; it's just shifting the potential pain points.
I do agree that reacts biggest weakness is css. For a "view" library they certainly dropped the ball on one of the two fundamental parts of what a view is in a web browser.
I don't think the issue is that you are biting off too much. The issue is that you try to do too many new things at once.
Ditch prisma, ditch typescript and just try something simple.There is not reason why you shouldn't use mysql if that's what you are familiar with.either build a standalone API that will be consumed by your next.js app or skip this step and just do it in next.js https://nextjs.org/docs/api-routes/introduction
for connecting to the database use something like knex and play around... once you are comfortable with this ecosystem then add typescript and then aftewards add prisma or whatever you want
Blindly copying pasting is a bad idea. You should always understand what you're doing, why said problem occurred, and how the solution works.
https://www.gitbook.com/book/tra38/essential-copying-and-pasting-from-stack-overflow/details
Depends on the problem you are trying to solve. Generally, Google is every software engineer's friend. Can't sort out Hibernate config ? SO has the answer. Having trouble remembering some SQL syntax ? Google will save the day ! Some framework is throwing an exception ? Ask for help using teh interwebs.
But, if you're trying to come up with an algorithm to some homework you got in school, sit and figure it out on your own.
TY for v12 Next.js Team!.
Looks the the upgrade won't be hard due to small # of breaking changes (depending on projects but not for me ;p )
Time to enjoy the faster rebuild/refresh w/ Rush compiler.
Currently, not yet. Soon, yup.
The next big step in React seems to be Server Components where it's basically the component managing the data it needs on the server side (i.e. fetching) and delivers to the client only the code it needs (i.e. static DOM).
Next.js should naturally follow this path; maybe they'll address it during their conference happening on the 15th of June (https://nextjs.org/conf)
More info about React Server Components: https://reactjs.org/blog/2020/12/21/data-fetching-with-react-server-components.html
Ghost is decent, like people have said, but there's also Hugo. I played with it once, but I'm not a huge blogger so it didn't make much sense to keep messing with it.
Edit: Never mind, can't really do the mobile thing. :P
Modern flat-file CMSes are becoming more popular for smaller mostly-static sites (eg. local businesses) due to their simplicty of implemetation, programmer friendliness, and adoption of useful technologies like Twig, Markdown, YAML etc. Kirby and Grav are worth checking out. That said, many clients will prefer the WordPress backend because they know it and it's quite a good WYSIWYG editor.
> In the end, I want working on the frontend to feel like working on a web app, so that it's familiar to web developers, follows best practices, etc. We already have, as a project, many ties to Ember, and so I chose it mostly because it feels like a solid, default choice.
I don't particularly enjoy working on web apps so that's probably part of my objection :)
>One thing that this could enable is a mode wherein you run rustdoc in the background, and as you tweak your code and the docs, it automatically updates in your browser. It won't do that today, but the way it's built fundamentally makes this possible.
I don't see any reason that would be incompatible with static pages. Hugo has "hot blog reload" and it generates static pages.
Please don't take my comment the wrong way. I'm very, very happy rustdoc is getting some much needed love and decoupling it from the compiler will make it massively better! I just don't think that rendering static documentation warrants the technical complexity of a web-app framework. It seems to me that using an existing Rust templating library would be sufficient for rustdoc.
Well she's fat and kind of old (I estimate she's 1.5 years, which is old for a jumping spider) so that helps, I don't let the younger ones out most of the time. I wrote a draft of a pet keeping guide but it's kind of a mess https://www.gitbook.com/book/melissamcewen/jumping-spider-salticidae-care-and-keeping/details
With those requirements, I'd recommend Jekyll generated and hosted by GitHub Pages.
You just push your markdown to a repo and it'll update your site, they handle hosting and you can still use a custom domain if you have one.
So Next runs on both the server side and the client side.
Anything that uses fs must be run on the server side because fs is the Node file-system module. Importing it creates the error because whenever you import code, you also import everything which that code imports... unless it doesn't exist, then you get errors like this.
Try moving whatever logic you're using to an API route and then calling that API from your client.
Nice work. Do you know Jekyll? It is a similar CLI program that allows you to use an HTML template for all your static pages.
Maybe it could be cool make your GUI work with Jekyll as a backend.
😳ty. All the pages are statically built with Next.js and the proposals page is using a cool feature called Incremental Static Regeneration so that once per hour, it will rebuild the page with the latest data from the READMEs instead of using the cached statically-built page: https://github.com/saadq/proposals.es/blob/main/src/pages/index.tsx#L30
Regarding Perl6, here's a couple things:
- See this guide: https://github.com/dnmfarrell/Perl6-One-Liners
- See this book: https://www.gitbook.com/book/kyclark/metagenomics/details
- One benefit of going with Perl6 is that the community is pretty close and tight-knit. So if you hang around for a couple of weeks, you'll basically be part of the "in" crowd.
I'd suggest checking out the first one-liner guide and seeing how you feel about it. I think Perl5 still has a good future. It's getting better all the time and it truly is fast (which can't really be said for Perl6 right now).
I'd recommend reading through the Next.js docs to better understand how you can use the framework. You can fetch data with client-side rendering and use Next.js as a single page app, just like Create React App. Then the question isn't "which framework is better?" but more so "which data fetching strategy makes the most sense for my use case?"
Netfily or Githube Pages can be used for free. As an alternative to Zim, Hugo might be an option. Its Markdown files can be easily created in any editor and the changes can be deployed automatically.
https://gohugo.io/hosting-and-deployment/hosting-on-netlify/
Caliban and the Witch <em>Women, the Body, and Primitive Accumulation</em> - Silvia Federici
>a history of the body in the transition to capitalism. Moving from the peasant revolts of the late Middle Ages to the witch-hunts and the rise of mechanical philosophy, Federici investigates the capitalist rationalization of social reproduction. She shows how the battle against the rebel body and the conflict between body and mind are essential conditions for the development of labor power and self-ownership, two central principles of modern social organization.
Next.js is an opinionated framework for building React applications.
React, alone, is just a library. To make an typical react application, you need much more than React. You need Babel to transpile your JSX. You need webpack to bundle your code into packages a web browser can consume. You need plugins and a bunch of configuration to make things like CSS/SCSS work. If you are building a Single Page Application (SPA), you need some library to handle routing (e.g. react-router). If you want to marry data from a data source (e.g. a database) to create a site using static site generation (SSG), you need an engine that renders static pages from your React templates based on the data. And so on...
Next.js solves addresses all those things (and more) in an easy to use package. Of course there are other frameworks that also address those things (e.g. Create React App). One of the main differences with Next.js is that is also provides a backend runtime that supports server side rendering (SSR) which is much better for SEO as the initial response from the browser is a fully rendered page instead of a skeleton that gets filled out a half second later with content when React spins up.
Next.js also provides more interesting approaches than simple SSR like incremental static regeneration (ISR) which combine some of the best parts of SSR and SSG.
Finally, Next.js also provides a basic set of capabilities for exposing APIs from the backend (which might otherwise have been created separately with an Express.js backend).
The front page of https://nextjs.org/ has a pretty good section on "Why?". You can do all the things that Next.js enables without Next.js, but it will be a lot of work. Next.js lets you focus on your application instead of on plumbing.
Namecheap - .com = £7.08/yr, .co.uk = £6.05/yr with privacy
A lot of the big brand registrars have horrible reputations and predatory practices
eg. buying domains you search for and "helpfully suggesting" that they can negotiate to buy from the "owner" at a higher price
search reddit for horror stories about GoDaddy etc.
Jekyll + Netlify = £0
I do have a personal page (I don't want it associated with this account) that I created at the behest of my supervisor.
I don't use it a lot, and I'm pretty sure no one's ever contacted me because of it.
It was useful, though, to learn a bit of web tech. I used Jekyll to build it, and I think it turned out nice.
Despite the lack of a social aspect (following, friends, etc.) I ended up hosting my own blog/website powered by jekyll.
I chose it because I'm a big fan of writing with markdown syntax, and jekyll allows you to write posts and pages using a really nice markdown/html hybrid.
It's super quick to set up, and you can host on github.pages for free!
Fast, flexible and with loads of themes to choose from. I can't recommend it enough.
Wow WordPress security ignorance justifies building an entire CMS from scratch? Ok... or just harden your WordPress server and platform. Huge enterprise-class sites are powered by WordPress and are secured pretty easily these days.
Or use one of the other mature CMS platforms out there. I like Grav: https://getgrav.org/
volevo consigliare (questo libro)[https://www.gitbook.com/book/swaroopch/byte-of-python] a chi vuole imparare python ed è completamente a digiuno di programmazione. Ho trovato valido anche "Learn Python in the hard way" (che consigliate spesso qua), ma questo è più ELI5 e mi ha chiarito molti dubbi (ossia cose che chi programma dà per scontate).
Android fundamentals course > This course is intended to be taught in a classroom, but all the materials are online, so if you like to learn by yourself, go ahead!
While it's not from a teach
What you're looking for is web3.js
It's a JavaScript library to allow connecting to an ethereum node, and performing lookups and transactions. This wires up quite nicely into any existing webapp/site, whatever you're preferred development style is.
What's quite important when starting development is deciding whether your app connects to a server at all, or relies solely on a user running their own node.
Also worth knowing from the start is whether your app will rely on existing contracts, or yet to be developed contracts, in which case you're just going to be using web3.js as development tooling to debug and test your contracts before being able to design an app to make the interaction seemless.
Edit: I wish I could have pointed you at https://www.gitbook.com/book/d11e9/developing-dapps/details but I'm still busy writing 😅 you can register to be notified when it's done, if you like
Are you prepending your variables with NEXT_PUBLIC_ ? You’ll need to if you want to use them on the client.
> I just worry about rhetoric normalizing violence
I hear that, but I think this is more blowing off steam than anything.
Since you say you're new to leftist thought, a suggestion that I have is to read Caliban and the Witch (https://www.gitbook.com/book/anarchivists/caliban/details). Everyone should read it: It's a great history of the creation of capitalism and its affect on workers, particularly women. When you get into the actual barbarity of that system from its inception, maybe you'll want to blow off some steam with guillotine jokes too--or at least be more understanding of those who do. (I mean that less patronizing than it came off, but I really do recommend the book since it really can shift your perspective on what violence is.)
> copy another developer's work
Apple? How... how do you think programming works?
edit: Sorry, that was a joke, I need to make it more clear I guess.
They have a whole section about converting create-react-app to next, which is pretty awesome. This is probably helpful even for a general react app.
- You don't need to create a separate backend - you can use API Routes! If you already have an existing backend, you of course could just continue calling that. Next doesn't really care where your data is at :) Note the "custom server" in the docs is completely overriding the Next.js server, which is different than having your own Express server with an API that your Next.js app talks to.
- getInitialProps is an older API, which has been essentially replace by getStaticProps (static) and getServerSideProps (server-rendered) is most cases. There's still a few use cases, but the majority of the time, you should be using the other two. You can read more about it on the original announcement post: https://nextjs.org/blog/next-9-3#next-gen-static-site-generation-ssg-support
getStaticProps is only executed at build time, so whatever data is present when you do your deployment is what's going to be shown on the site.
You have two options to fetch new data with getStaticProps:
- Trigger a new deployment via a Deploy Hook
- Use incremental static regeneration.
I find that restructured text is overkill for almost everything I do. I get frustrated when I have to lookup too much arcane syntax, and I'm just trying to write pretty simple things like READMEs and some narrative documentation. Markdown and MkDocs does the trick.
I think you need a more straight-forward and simple documentation if you intend to attract a wide audience. There is no real guide to getting started, and that's a bigger selling point for me than anything. I would have to try it out myself before I render an actual opinion, but so far it sounds good. I'm a big fan of Pelican (http://getpelican.com/), which is documented really well. so I might just be a little biased.
If you want to make your own here's a quick bit of javascript that you can modify:
<span id='countdown-nms' class="countdown"></span> <script type="text/javascript"> (function() { var f = function(n) { return n < 10 ? "0"+n : n } var out = function(d, h, m, s) { return f(d) + "d, " + f(h) + "h, " + f(m) + "m and " + f(s) + "s" } var el = document.getElementById('countdown-nms') var to = new Date("2016-08-10T00:00:00+0100") setInterval(function() { var diff = (to.getTime() - Date.now())/1000 if (diff > 0) { el.innerText = out( Math.floor(diff/3600/24), // Days Math.floor(diff/3600)%24, // Hours Math.floor(diff/60)%60, // Minutes Math.floor(diff%60) // Seconds ) } else { el.innerText = out(0, 0, 0, 0) } }, 1000) })() </script>
The date I've used is for the UK countdown so you might want to adjust it. If you're a Hugo user and you want to add countdowns to your theme, this code is just a modified version of a shortcode I wrote. Source here: https://github.com/nboughton/hugo_theme_robusted/blob/master/layouts/shortcodes/countdown.html
Thank you, I'm glad you found it helpful!
I write all my blog posts in org and then convert them to HTML using Emacs. These HTML files are then used to build the entire site with Jekyll. I created the theme and layout myself - you can probably tell I'm not artistically talented :)
I said this for years before it finally “clicked” for me.
Check out Jekyll. It’s basically plain text with styling in Markdown. Tons of free templates available, and you can host for free on GitHub by simply changing where your personal domain points to.
DM if you want to know more or need some help.
Take a look at Jekyll, a static site generator which you can use with GitHub Pages. You've probably got no need for something as complicated as Laravel, all you should need to know is HTML, Git basics and how Jekyll works.
That said it all depends how non-static it is. What do you intend to do with storing contacts?
If you're not comfortable with code at all, take a look at Wordpress/Squarespace, it can probably do what you want without having to roll your own CMS
Hi,
Next time it would be easier if you write on /r/ArenaTracker this way I can help with some troubleshooting in the correct place.
Sometimes AT might fail when detecting the cards but that is not common and is more related with golden cards. When wrong cards are detected you can force AT to reescan the screen by using the refresh button on the top-left (You can see it on your screenshot). You can also click the the card detected on AT and a top-down list will appear with alternative results where you can choose from.
In case there has been any problem downloading the cards you can force a download again by removing the dir Hearthstone Cards located on USER/Arena Tracker and restart AT.
If you don't want to download all the cards again I have download them from my client and put them here. Extract the zip on USER/Arena Tracker to rewrite your old Hearthone Cards dir.
Triodo
Edit: To know more things about AT you should take a look at the user guide.
Using LLVM would bring a lot to the table from what I know. It would save us from having to deal with generating assembly on multiple archetectures. And there is already support for JIT compilation too. It also makes interop with C painless.
There is also two extensive tutorials on how to build a language using LLVM with a JIT, one in C++ and the same tutorial in Haskell.
Well...
- All Flesh Must Be Eaten is a game of zombie horror, with various knobs and dials you can tweak.
- Call of Cthulhu could be adjusted to zombie horror without much trouble. It's a quick, fairly-lethal system based on percentile skill checks (i.e., your skill in whatever is at XX%, you roll percentile dice and try to roll at or under your skill).
- World of Darkness could certainly be used for zombie horror, just don't use any of the supernatural splats. It uses a d10 dice pool system (roll Xd10, each one that rolls 8+ is a success, the more successes you roll the better you do).
- Fate Core, Fate Accelerated, or Strands of Fate will work if you're interested in trying a more narrative system style. However, these don't use grid-based combat, so that might not be your thing.
- Similarly, there appear to be a couple of (in progress?) zombie games using the *World system... Zombie World and ZombieApocalypse turn up in a search. I can't comment on those in particular, but they're based on Apocalypse World, Dungeon World, and those other *World games, which are very popular narrative-style RPGs.
Don't you EVER link to that overseo/spam nightmare of a website again.
Here's the direct link: https://www.gitbook.com/download/pdf/book/samypesse/how-to-create-an-operating-system
Here's the actual website of the actual author: http://samypesse.gitbooks.io/how-to-create-an-operating-system/
getStaticProps technically is, the props get injected at build time, but the result is a static artifact. Using getServersideProps will make any page no longer static. Data is read from each request and used to build the HTML to respond with on each call.
Next is technically a Node.js framework that spins up a server that returns a page which includes React at each route. It also supports server-side logic in the form of API routes. A Next.js app requires a Node.js runtime, so on that hosting website it would fit under the 'Services' category.
If you're not using any dynamic features of next, you can use Next's Static Export API to have a static-only bundle that can just be uploaded to and served from a file system. I have not used it myself, but it seems like it may fit your use case.
This, in combination with the native internationalized routing capabilities of Next.js: https://nextjs.org/docs/advanced-features/i18n-routing
Having both of these should get you pretty far. Also, don't worry about none of the languages being English. Most translation related libraries don't assume anything about a "base" language so you should be fine.
It's very important to also read up on the "loaders" section of the next/image documentation (https://nextjs.org/docs/basic-features/image-optimization#loader). If you setup a loader, Next.js doesn't actually do the image processing itself, it just creates a URL with image dimensions and quality for your image service to handle.
In your case you assume that all customers benefit from seeing the post cover as a 500x500 image, and not scaled up or scaled down. But different devices need different images. Some might benefit from a 1000x1000 resolution image, some 250x250. Some might want webp as a format, some can't handle that and want jpg instead.
Next/image makes all these decisions for you and adds some cool stuff like lazy loading and "blur up" image loading. Things you'd all have to do yourself or with an external library if you don't use next/image.
So, I would first reevaluate whether your architecture for a custom image back end in S3 is actually the best option. Why not use an image CDN built for this, like Cloudinary, Imgix, etc. Or create your own custom next/image loader and use any image CDN with enough features to your liking?
Second: check if you're not making too many assumptions about the devices people will use to check your application. If you let go off these assumptions you might find that next/image is a very helpful tool to serve images exactly the way your visitors need it.
Good luck with your project! 👍
It looks like environment variables are what you’re looking for: https://nextjs.org/docs/basic-features/environment-variables
These allow you to set a constant in a config file then use them in your code. On production you set a different value for this variable. Vercel, for example, let’s you set these variables for each environment.
There are two kinds of Next.js env variables too - ones the client can see which are good when you need an API endpoint for the client to switch (which start with NEXT_) and server side only Env variables which are good for things the client should never see.
Using this approach you could set a API_ENDPOINT variable and use that with process.env.API_ENDPOINT in your server side props function. If you need to use this variable on the client side, you’ll switch it to NEXT_API_ENDPOINT and access it from both.
I typically have the pages folder (as is required) and a sibling folder called src. This folder is usually broken down into client and server folders, and from there I would have stuff like you mentioned, components, styles, utils, etc, in the client folder.
You can cut down on path lengths by aliasing paths. I usually at least create a mapping to my src folder, but you can get crazier.
> There’s no actual client-side rendering for pages.
This is incorrect, I think. The initial render happens on the server, but once the client code (JS files) has finished loading, the rendering happens on the client again (as in, route transitions happen on the client, as with usual React apps). This has an explanation: https://nextjs.org/docs/basic-features/pages
literally the first thing on the docs > Recommended: getStaticProps or getServerSideProps
> If you're using Next.js 9.3 or newer, we recommend that you use getStaticProps or getServerSideProps instead of getInitialProps.
> These new data fetching methods allow you to have a granular choice between static generation and server-side rendering. Learn more on the documentation for Pages and Data fetching:
I see a lot of people here rightly pointing out performance issues with this site, but (given the title of this post) are people implying that the choice of Next.Js is at fault?
If static HTML export (or at least some sort of document response caching) is being used, server side rendering wouldn't exist to slow anything down, so the only real Next.Js-related performance bottleneck (on initial load anyway) could be "re-hydrating" the SPA's state to match the pre-rendered page, which I would imagine wouldn't be too noticable or significant.
So surely the main issue is their particular implementation, right?
ParseInt, the Go function has that explicit base argument.
<code>int</code> does not. In Hugo, that int is a template function.. think of those as the only functions that a user can use in their site templates.
In the templates, I cannot use the core Go functions like ParseInt directly.. so explicitly providing the base is not a option.
Ah, thank you! The site certainly works well; I'm a software dev in real life so I'm good at that part. My self-consciousness is about the math itself. I can't, for the life of me, get myself to do really careful rigorous math, so I don't... quite... trust myself to write about anything abstract like exterior algebra without making glaring mistakes. Even though I like to try. Plus there's also the general self-consciousness that comes with posting anything online.
The Wordpress LateX plugin is definitely bad. My site is built on Jekyll and hosted (for free) on Github pages. The TeX is through KateX which is like MathJax but much lighter weight and loads a lot faster (and it doesn't make the page reflow = reorder everything / move around as it loads the math).
I believe that even on Wordpress you could set things up so that KateX or MathJax parses math via Javascript when the page loads, but I haven't tried. It might require paying for Wordpress to modify the Javascript on the page. Can't remember
In the nicest way possible, your writing on this site might reach a larger audience if you spend a weekend reading up on best practices in website design. Alternatively, you could have a look at blogging tools like Jekyll that will do this for you.
- If you're doing this project to learn as much as possible, I would recommend trying to build a simple CMS yourself. I'm sure there are lots of tutorials out there. If you're trying to get this project done ASAP I would recommend using a static CMS like Jekyll on a subdomain. You can use Wordpress on a subdomain really simply also. But that is over-kill if you just want a simple static blog.
- Yes, definitely.
- Sublime Text is a text-editor while RapidWeaver looks like drag-and-drop website builder. The two aren't really comparable. I personally think most drag-and-drop website building apps are pretty crappy and result in subpar sites. If someone can only create sites using tools like that, then I'd hesitate to call them a web developer. But that's just my opinion ;)
Good luck!
Wordpress is pretty popular as a platform. If you're not opposed to learning a little HTML & CSS I highly recommend Jekyll. There are plenty of really nice looking themes to use, you have a ton of control over your site if you choose to customize.
It's an awesome way to show potential employers that you are competent with web technology. Another huge bonus is that you can use Github Pages to host your site for free.
I always found the best way to figure out a stack is to set up my local dev environment to mimic it. It helps with learning how to configure everything with the added bonus of it working exactly how it would in production.
Right now I use OSX with apache and php the steps are almost identical to setting up a LAMP stack on a linux distro.
Here is a good tutorial to follow in regards to setting up a LAMP on osx although this tutorial talks about different php versions.
https://getgrav.org/blog/macos-sierra-apache-multiple-php-versions
I took pride in doing mine from scratch, just because I like being in control of what I build and I enjoy making websites, free from the constraints of project managers, stakeholders, etc., etc.
That being said, I just DO NOT have the time anymore! The latest incarnation of my site uses a template built on Grav (which I can highly recommend - Wordpress without the database: getgrav.org).
In two (admittedly long) nights I had re-purposed a template to fit my needs and published it. Can't argue with speed like that. As long as the quality is there. Which it is.
This allowed me to focus on the content rather than the presentation, which hopefully has resulted in a better portfolio site :)
I'm looking to create a generic skill system framework along with in-engine tools for quest design.
As for games, I'm interested in a variety of 2D turn-based titles: for now, a Vim-like RPG and a tactics game where time loops around repeatedly.
I also have a long-term project I intend to try out in Godot of using dialogue with a constructed language as a means of scripting content so that I can narratively describe content that results in generated gameplay changes.
I haven't looked much into Django Girls, but I've read parts of their tutorials when I needed help understanding things. It's a good resource. Here's the link I'm talking about, it's an e-book/blog project:
https://www.gitbook.com/book/djangogirls/djangogirls-tutorial/details
Not an expert, but you are doing great. What you need to do is style the output.
Something like TailwindCSS makes that a breeze.
https://nextjs.org/blog/markdown
Or you can check this out
https://www.pullrequest.com/blog/build-a-blog-with-nextjs-and-markdown/
Best of luck.
You have to be explicit in what paths are to be rendered with getStaticPaths, even for a dynamic route. If you don't have a finite number of options for the slug, then you won't be able to prerender. Docs: https://nextjs.org/docs/basic-features/data-fetching#getstaticpaths-static-generation
To give a practical use-case for this, I built a site for a photographer recently. Several folders of images, varying numbers of images in each folder. I can use getStaticPaths to read each folder and create a path for each image. Each of these image pages is now prerendered and can be accessed via that slug now at the [slug] page.
I’d use a catch all route.
Let’s say you have a product page, pages/product.js.
This would get you mysite/product/some-product
To use a catch all route, rename product.js to […params].js and put the renamed file into a /product folder, like this: pages/product/[…params].js.
Now, you can add any amount of additional parameters to the URL and they’ll all be put into an array you can use on the product page.
For your request you would then use these URLs: - mysite/product/some-product - mysite/product/some-product/with-warranty - mysite/product/some-product/some-other-thing
Within product/[…params].js, you’ll now get an array like this from the router: - { “params”: [“some-product”] } - { “params”: [“some-product”, “with-warranty”] } - { “params”: [“some-product”, “some-other-thing”] }
For full documentation check out this page:
https://nextjs.org/docs/routing/dynamic-routes#catch-all-routes
I (and countless other devs I imagine) have tried this a few times and I think it's not as useful as it immediately appears. I'm not saying it's a bad idea or anything, but I am less enthusiastic because:
- not everyone will understand or want the technologies you choose to include
- there are many OK ways to set up a Django project, and not everyone will want the config style you choose
- you yourself may want to tweak something every time as you learn new things or develop new tastes, making your scaffolding less convenient
A lot of the work that a scaffolding tool, or any library really, needs to do is convince you that it's making all the right choices and that you can either understand the choices it made or those choices are abstracted away. create-react-app or nextjs come to mind as examples of this done really well. So it is possible, but I imagine it is also much, much more work than it seems to do this well.
Performance is a factor. By removing the need to download the js bundle before rendering and directly serving the HTML can mean the time to first paint is quicker, especially on a slower mobile connection.
​
The other motivation is SEO. Google has come a long way with processing javascript SPA however I've had problems in the past when data is loaded from an API. e.g. it may index the content contained within the js bundle but the posts loaded from a remote API may not be properly indexed.
Other applications also often rely on meta tags, e.g. Open Graph, Twitter Cards, etc. That often don't have support for SPA's.
Depending on your stack, for React projects https://nextjs.org is great option IMO.
If you do really think the current style is a problem feel free to raise it on the discussion group to see what others think - we use MkDocs, so it'd be easy enough to change the theme to eg. the built-in mkdocs style... http://www.mkdocs.org/
At work:
- Ruby + JS (we mostly do Rails applications at my work)
At home:
- Java - I've been going through Cracking the Coding interview the past couple of days, using java since I'm most familiar with it from school.
- JS (node.js, AngularJS) for any personal web projects
- Haskell - writing my blog in a haskell static site generator called Hakyll
Gatsby must be quite heavy for your requirement it seems. However, I can suggest you to checkout hugo which only requires you to write HTML templates, markdown content and config.toml
Other than that, 11ty which is feature rich but requires you to write Javascript.
I'm not aware of any Nim framework that achieve the same, would love to see if there is any!
As you see, lots of folks suggest WordPress is totally fine as long as you spend a deal of effort hardening it and time managing it.
Meanwhile, my question would be: what do you need it for? Are you just doing a simple blog? There are great static site engines that would render your posts for you and you wouldn't have to worry about vulnerabilities or a database or anything like that.
Check out Hugo if this fits your needs:
There are plenty others just a Google search away. If this isn't what you need, enumerate your needs and there might be a much better fit for you than WordPress...
I have been using hugo, a static site generator for a personal blog-like project. The theme system is fairly simple so customization should be quick. The generator itself takes markdown files and produces html quickly. Very easy learning curve.
Just an alternative suggestion. Have a good one!
Yep Github Pages will be fine for you. You can use Jekyll on Github pages, so it's quite easy to set up the structure for a multi-item portfolio, or case studies, etc.
I host a number of projects on Github Pages, and use Jekyll on a few too -- most notably my blog is Jekyll/Github Pages.
Jekyll is very easy to use, and you can even get pre-made themes if you're not very technical.
You're using PHP as a templating engine, which is totally fine. There's nothing wrong with it. It'll make your site slower than just serving static files, but not by much.
You could look into learning some build tools which you could use to compile templates into static files so that you don't have to do the tedious work of copy-pasting the nav/footer yourself. Or you could simply use something like Jekyll. It requires setting up Ruby, but it has really nice integration with GitHub pages so you could get started with that.
opensourcerails.com has some nice examples.
Edit: though personally, I'd recommend Jekyll over "rails". But wether that fits, depends a lot on your requirements. You don't list any, just that it must be rails. Why is that?
You really have some clean code there.
Don't fuck it up by wrapping with wordpress clutter and junk.
p.s. github pages runs Jekyll, you just push and it runs, no CI required unless you want to do custom plugins. https://jekyllrb.com
There's a few different ways you can do it.
1) If your server allows it you can use php and then use a php include for the header file. Locally you'll have to run something like MAMP/WAMP to test it.
2) You can include it using javascript. Not the best practice, but it does work.
3) You can look into a static site generator such as Jekyll which will let you have partials or templates.
Personally, #1 is the easiest way to handle it, and most servers are going to support it anyways.
Yes. As simply as installing the app (and prereqs like Node.js) on any linux VM and running:
next buildnext start
This can quite easily be in a docker container as well. There are many many places you could choose to host this way. Many places (I have tried both Azure and DigitalOcean) have app platforms that you can just point at your repo and they will detect that it's a node.js app and build the docker image for you every time you commit.
If you want serverless, the choices are reduced but there are still several. AWS Amplify does it, Netlify does it. I expect there are others, but those are the two I see most often. You can also roll your own if you want, it's just more work than the next start option above.
See for more details on both the Node.js and Docker options in the official docs here: https://nextjs.org/docs/deployment#other-hosting-options
Recently released PDF OWASP Mobile Security Testing Guidelines for whoever is interested in Mobile Security Testing.
For moving further, you can try this OS - Android Tamer, which has inbuilt tools for Android Testing.
My coworker rewrote man to use the top result from stackexchange. Everyone uses google. There is a reason this joke is a thing
Just apply to everything. Don't waste your time with a cover letter. Put together a resume, your college will likely have a resource to get you some help with that. Blast out as many as you can, things that you aren't qualified for too. All they can do is say no, or not call you. You don't need a great job, you just need any job in the field. Once you get some experience, it's easy to find a follow up job. It's only the first one that is hard. After that, it's easy as hell to find a position.
You could also apply for something in DevOps, they want people who know how to code, and are willing to do Ops stuff as well. The field is generally pretty heavy on the ops side, so you could probably get by with knowing very little of that, but being able to code much better than most of the other ops heavy guys (A vast majority can barely do more than basic scripting).
Suave will probably be what you're looking for:
I set up the anarchivists account with this in mind and would love to turn it into a thing. If anyone is interested, PM me (or post below this comment) and we can discuss details.
Agree, a slow down is in order. A general rule of thumb is that if there's not already a tutorial out there that tells you how to get that exact job done, you're not gonna wrap your noodle around it immediately.
That said, the tutorial for docpad will get you, I think, probably 90% of what you are looking for. The "getting started" tutorial also shows you a basic templating engine they recommend and how to get live reload working.
Is there a reason you can't use the NextJS dynamic ?
​
https://nextjs.org/docs/advanced-features/dynamic-import
​
Might have better luck.
NextJS is a framework that includes a react based front end and a node based backend, so no real need to have a separate node backend.
You might be looking for this:
https://nextjs.org/docs/advanced-features/custom-server
Where you can override or extend the built-in backend of NextJS
Nope, that's pretty much it. From the docs:
>Prefetch the page in the background. Defaults to true. Any <Link /> that is in the viewport (initially or through scroll) will be preloaded. Prefetch can be disabled by passing prefetch={false}. When prefetch is set to false, prefetching will still occur on hover. Pages using Static Generation will preload JSON files with the data for faster page transitions. Prefetching is only enabled in production.
It's worth noting that what is being prefetched is the props for that page, it's not fetching images or anything - so usually each prefetch is a handful of kB.
They're also cancelled if the user initiates another navigation I believe.
Also, if you are completely new to NextJS you might find this walkthrough helpful. It's not too long and walks you through the main parts of a Next app:
Oh, I’m in the same boat! Made a quick QR generator project for work using Next.js, but I didn’t explore many of the features and didn’t delve into data fetching on that one. I’m currently working on a portfolio built with Next, feeding data from a separate server running Strapi for the backend.
Here’s the Next.js docs on data fetching: https://nextjs.org/docs/basic-features/data-fetching
I’d keep the axios bit in there as it will be valuable for the employers not using next.js, but just so you’re aware for the next project :)
P.s I’d also recommend looking into something like Storybook that lets you separate your component logic from the pages, enabling you to create a single source of truth complete with docs on each component.
It may seem wrong, but what you are experiencing is simply how Next-js currently functions. They mention it under 'caveats' at the bottom of this page: https://nextjs.org/docs/advanced-features/automatic-static-optimization
Simply stated: if u add getInitialProps to _app, and actually need live data on each page, forget about static page generation. It would be nice if they added this functionality in the future, but it would somehow devaluate the use of static generation if some data on the page should still be fetched and the DOM rerendered.
For now: u could just use getInitialProps on the about.js page, disabling static generation all together. (Im still waiting for a way to use getServerSideprops on app.js)
It is, next has naturally a server that is used when calling getInitialProps in server side rendering or with the api routes, that I think it is the case you are looking for. Check https://nextjs.org/docs/api-routes/introduction
Do you have React experience? If so, I recommend just going with Vercel's own starter tutorial https://nextjs.org/learn/basics/create-nextjs-app
If you are new to frontend and/or React, I recommend starting there before tackling Next.
Like the other comment says, you do them as two separate projects. I personally prefer putting another app in a subpath instead of a subdomain though:
I think you're talking about getStaticProps and getStaticPaths in next.js. Here
OP, Do take a look at them, because they serve the exact purpose you're trying to solve and even have a bunch of examples to fiddle with.
You are correct – Next.js is server-side rendered (SSR) out of the box. During the compilation process, Next will look to see if your page uses getInitialProps or getServerSideProps. If it does, that page will be SSR. If it does not, it will render as static HTML. This is referred to as "static pre-rendering" and it's an optimization of Next.js.
Depending on the type of application you're building, a completely static site might have better performance than SSR. This is why Next.js 9.3 added getStaticProps and getStaticPaths to make it a complete static-site generator (SSG). This is discussed a bit further in their data fetching documentation. Static sites have many benefits:
- Globally scalable
- Save money hosting static files
- Faster performance by serving cached assets from a CDN
- No need to worry about server or database vulnerabilities
- Better developer experience – no complicated deployment process
If you want a tangible example, I just wrote a tutorial on Next.js 9.3. Happy to answer any other questions. Either SSR or SSG will be good choices for improved SEO over a client-side rendered (CSR) application.
Just to be clear what is collected is completely anonymous:
- No IP addresses are stored and your project is not identifiable in any way
- It's only enabled during development and build time, never during production
- Only plugins from a whitelist are tracked (for example @zeit/next-css, @zeit/next-sass and the likes) this helps us in deciding which features to develop or spend more time on
- The CLI gives a clear message when booting up for the first time in a project that telemetry is enabled and links to the telemetry page if you require more information.
Furthermore telemetry itself is now extremely common in large projects, including massively popular ones like VS Code.
Unlike these projects, Next.js does not track stacktraces which could include sensitive information.
Security, compliance, and transparency were top priorities in rolling this feature out, and a big motivation behind writing the blog post and making the twitter announcement.
Make a blog with existing methods with static site generator, where you can host them on gh-pages; many of them have free themes. Start writing about what you've learned, or you can teach others or whatever you think is worth a post. Perhaps make a "project" category for all the projects you've contributed to, and highlight the ones you're proud of.
How about reconsidering your criteria getting rid of the database and dynamic content, and trying a static site generator like Hugo? This removes nearly all of your threat surface.
1) To get a website at username.github.io, the repo should be named username.github.io - note: that will only work for your username. Full details here
2) GitHub Pages is a hosting service, that uses Jekyll to auto build if it needs to, but can host any static site.
3) Jekyll is a static site generator. Basically, it takes a directory of markdown files, applies a theme to them and produces HTML for them. The official site will go into more detail about how it does that. It was initially created by one of the GitHub founders.
4) If you are using Jekyll, you can apply different themes to your site to change the aesthetics. It's all HTML, CSS, and JavaScript at the end of the day so they are the main ways to alter the aesthetics.
edit: added link to pages documentation