html.about.html Maven / Gradle / Ivy
About Hyperscala
What is Hyperscala?
Hyperscala is a statically typed bare-metal HTML, CSS, and JavaScript framework for Scala. What does that mean?
It means you can write web pages in Scala entirely without markup. Hyperscala, unlike many frameworks in the web
framework arena, is at its core a bare-metal framework. This means that we've done our best to perfectly
represent HTML, CSS, and JavaScript so that there is nothing that can be done in a webpage that cannot be
replicated in Hyperscala.
What if I already have HTML?
Great question! The goal of Hyperscala is to make web development easier and the honest truth is that sometimes
it's just easier to write markup or you already have HTML you'd like to use. That's okay, we understand and we've
created a lot of ways to make use of existing HTML. The first option is just to plug it in. You can use the
StaticHTML class to inject a snippet of HTML code into your page as-is without any changes. This can be
problematic though because rarely do you need to just work with static content, you usually need to modify it.
To that end there are two other ways you can interact with the existing HTML. The first option is to convert it
to Scala. We've provided a utility that can take any existing HTML file and convert
it to Scala source code utilizing Hyperscala. This is great when you are porting over and the developer will be
maintaining layout and design going forward. Unfortunately, this does not take into account the separation of
developer and designer. Good luck trying to convince your web designer to learn Scala. This is where the second
option comes in. Through the use of DynamicContent and DynamicTag (which is used in the page you're reading right
now) you can pull in snippets of HTML (similarly to StaticHTML), but extract elements out by id and modify and
introspect them to your heart's content. Though it would seem like this would be incredibly slow, it's actually
optimized to the extent that in most cases it performs faster than any other option. It's sort of like a
dynamically regenerating JSP file that only deals with the parts that have changed.
Isn't HTML a pain?
Yes, we sure think so. Though at Hyperscala's core it is nothing more than a statically typed Scala framework
that lets you write HTML there's so much more to it. We started with the core because we don't want to make
assumptions of how people will use the framework. However, we've provided a lot of features on top that allow
developers a much easier and abstract way of creating and manipulating web pages. One of the core features is
the idea of Modules. In Hyperscala a module can be "required" by a page or component and will be loaded to
provide some functionality into the page. For example, there are simple modules that inject JavaScript
dependencies like jQuery (while avoiding multiple versions or includes from occurring) and other more advanced
features like Realtime that allows two-way realtime communication via WebSockets (failing down to AJAX polling)
for your page. Creating your own module is simple and allows libraries to be written and utilized without
the idea of using them overly complicated. There's so much more that Hyperscala provides, check out the
documentation for more information.