s3_website VS YARD

For my personal site, which is 10 years old, I use Middleman, and I deploy the site to S3/Cloudfront with s3_website. It works fine for now. If s3_website stops working, I'll move to Netlify probably.

resource "aws_cloudfront_distribution" "frontend" { enabled = true aliases = ["${var.subdomain_name}.${var.domain_name}"] is_ipv6_enabled = true // cheapest: https://github.com/laurilehmijoki/s3_website/issues/150 price_class = "PriceClass_100" default_cache_behavior { allowed_methods = ["GET", "HEAD", "OPTIONS"] cached_methods = ["GET", "HEAD"] target_origin_id = var.frontend_s3_origin_id viewer_protocol_policy = "redirect-to-https" default_ttl = 0 max_ttl = 0 forwarded_values { query_string = false cookies { forward = "none" } } } origin { domain_name = var.frontennd_s3_origin_domain_name origin_id = var.frontend_s3_origin_id custom_origin_config { http_port = 80 https_port = 443 origin_keepalive_timeout = 5 origin_protocol_policy = "http-only" // setting defined after terraform import. can try with https-only origin_read_timeout = 30 origin_ssl_protocols = ["TLSv1", "TLSv1.1", "TLSv1.2"] } } restrictions { geo_restriction { restriction_type = "none" } } viewer_certificate { acm_certificate_arn = aws_acm_certificate_validation.default.certificate_arn cloudfront_default_certificate = false minimum_protocol_version = "TLSv1.2_2019" ssl_support_method = "sni-only" } } resource "cloudflare_record" "frontend_service" { name = "${var.subdomain_name}.${var.domain_name}" value = aws_cloudfront_distribution.frontend.domain_name type = "CNAME" proxied = true zone_id = lookup(data.cloudflare_zones.default.zones[0], "id") }

JSDOC is a predefined method of documenting code for javascript ecosystem created in 1999 that works similar to libraries for other languages such as: Javadoc for java, YARD for ruby, etc..

In addition to project documentation, you've included a lot of code comments. You could adopt a standardized format and use it to generate API documentation. RDoc and YARD are two options. If I were reviewing this code at work, I would probably ask you to remove comments that explain what, not why.

I still just document everything using YARD and focus on designing really obvious Object Models and of course write tests. I have tried using sord to convert my YARD type annotations to RBS or RBI, but you still have to fill in missing bits, then use steep and somehow load in RBS/RBI files for other gems and stdlib, and it's just an uphill battle since Ruby is dynamically typed by default. Obviously Dynamic Typing lends itself more to Dynamic Languages, where you can call an arbitrary method and let the language VM figure it out at runtime. Static or Strong Typing lends itself better to compiled languages where everything needs to be resolved at compile time and converted into object code. If I need to work in a compiled language, then I'll use Crystal, which also supports type inference. TypeScript's type syntax is quite nice, but I tend to avoid writing massive JavaScript code bases where a Type Checker helps catch subtle bugs, and instead prefer sticking to minimal amounts of vanilla JavaScriot in order to keep complexity low and not overwhelm the browser.

I had a dig into the file history, and it looks like we have to go back to 0.7 to find the old tag list. Here we find the info we need to understand the intent of the @option tag:

YARD: http://yardoc.org/

I tend to follow along using the YardDoc comment style. It has many small things I love about it; an example is when yardoc is followed it can be used to generate RBS/Sorbet type files with the sord gem, you can also generate application documents similar to rdoc/sdoc.

That turns out to be a pretty common use case for markdown. Github, for example, renders your README.md is part of a git repo's "home" page. It's also common to have tooling that parses specially formatted comments in your source code and produce a documentation bundle, usually as a web page (ex. RDoc, YARD, JSDoc, etc.).

My first assumption was, that I should be able to generate markdown from the source. Same ruby and rails does now, but only tweaking a couple of parameters to generate .md files instead. YARD is being used for that and it supports any markup rdoc or yard.

I’ve long used the YARD format and chose to use that as my documentation syntax. I suppose I didn’t check with anyone on this decision and slowly started adding documentation. I want to use this post to synthesize my implicit decision and the benefits of using Yard as the documentation format.

That said, YARD is a ruby documentation tool that has a yard graph command you can use to dump a UML graph for your app into a .dot file, which can be used with lots of different graphing tools (usually graphviz but there are a bunch of online tools and open source projects that can visualize them for you).