remarks alternatives and similar packages
Based on the "Web" category.
Alternatively, view remark alternatives based on common mentions on social networks and blogs.
scotty10.0 3.0 remarks VS scottyHaskell web framework inspired by Ruby's Sinatra, using WAI and Warp (Official Repository)
yesod-persistent10.0 7.4 remarks VS yesod-persistentA RESTful Haskell web framework built on WAI.
hakyll10.0 5.0 remarks VS hakyllA static website compiler library in Haskell
postgrest10.0 8.7 remarks VS postgrestREST API for any Postgres database
swagger-petstore10.0 8.5 remarks VS swagger-petstoreswagger-codegen contains a template-driven engine to generate documentation, API clients and server stubs in different languages by parsing your OpenAPI / Swagger definition.
haskell-bitmex-rest10.0 8.5 remarks VS haskell-bitmex-restswagger-codegen contains a template-driven engine to generate documentation, API clients and server stubs in different languages by parsing your OpenAPI / Swagger definition.
aeson10.0 6.6 L1 remarks VS aesonA fast Haskell JSON library
servant10.0 6.3 remarks VS servantMain repository for the servant libraries — DSL for describing, serving, querying, mocking, documenting web applications and more!
reroute9.9 4.4 remarks VS rerouteAnother Haskell web framework for rapid development
markdown9.9 0.0 remarks VS markdownConvert Markdown to HTML, with XSS protection
neuron9.9 2.7 remarks VS neuronFuture-proof note-taking and publishing based on Zettelkasten (superseded by Emanote: https://github.com/srid/emanote)
espial9.8 5.1 remarks VS espialEspial is an open-source, web-based bookmarking server.
graphql-api9.8 0.0 remarks VS graphql-apiWrite type-safe GraphQL services in Haskell
wreq9.8 0.0 remarks VS wreqAn easy-to-use HTTP client library.
wreq-patchable9.8 0.0 remarks VS wreq-patchableAn easy-to-use HTTP client library.
webify9.8 3.1 remarks VS webifywebfont generator - converts ttf to woff, eot and svg
scalpel9.7 0.0 remarks VS scalpelA high level web scraping library for Haskell.
airship9.7 5.4 remarks VS airshipHelium + Webmachine = Airship. A toolkit for building declarative, RESTful web apps.
apecs-gloss9.7 0.0 remarks VS apecs-glossa fast, extensible, type driven Haskell ECS framework for games
scalpel-core9.7 0.0 remarks VS scalpel-coreA high level web scraping library for Haskell.
nixpkgs-update9.7 7.1 remarks VS nixpkgs-updateUpdating nixpkgs packages since 2018
haskell-kubernetes9.7 0.0 remarks VS haskell-kubernetesHaskell bindings to the Kubernetes API (via swagger-codegen)
postgres-websockets9.7 3.4 remarks VS postgres-websocketsPostgreSQL + Websockets
servant-auth9.7 5.3 remarks VS servant-authAuthentication combinators for servant
concur-core9.7 0.0 remarks VS concur-coreAn unusual Web UI Framework for Haskell
keter9.7 5.9 remarks VS keterWeb app deployment manager
react-haskell9.7 0.0 remarks VS react-haskellReact bindings for Haskell
req9.7 1.6 remarks VS reqAn HTTP client library
lucid9.6 2.7 remarks VS lucidClear to write, read and edit DSL for writing HTML
servant-elm9.6 0.0 remarks VS servant-elmAutomatically derive Elm functions to query servant webservices
digestive-functors9.6 0.0 remarks VS digestive-functorsA general way to consume input using applicative functors
hamlet9.6 6.5 remarks VS hamletHaml-like template files that are compile-time checked
telegram-api9.6 0.0 remarks VS telegram-apiTelegram Bot API for Haskell
HaTeX9.6 0.0 remarks VS HaTeXThe Haskell LaTeX library.
stripe-http-streams9.6 0.0 remarks VS stripe-http-streams:moneybag: Stripe API
stripe-core9.6 0.0 remarks VS stripe-core:moneybag: Stripe API
stripe-haskell9.6 0.0 remarks VS stripe-haskell:moneybag: Stripe API
yesod-auth-oauth29.6 2.0 remarks VS yesod-auth-oauth2OAuth2 authentication for yesod
tagsoup9.6 0.0 remarks VS tagsoupHaskell library for parsing and extracting information from (possibly malformed) HTML/XML documents
yaml9.6 0.0 L2 remarks VS yamlSupport for serialising Haskell to and from Yaml.
hbro9.6 0.0 remarks VS hbro[Unmaintained] A minimal web-browser written and configured in Haskell.
kubernetes-client-coreHaskell client for the kubernetes API. A work in progress.
backprop9.5 0.0 remarks VS backpropHeterogeneous automatic differentiation ("backpropagation") in Haskell
engine-io9.5 0.0 remarks VS engine-ioA Haskell server implementation of the Engine.IO and Socket.IO (1.0) protocols
graphql9.5 0.0 remarks VS graphqlHaskell GraphQL implementation
keera-hails-reactive-htmldomKeera Hails: Haskell on Rails - Reactive Programming Framework for Interactive Haskell applications
android-lint-summary9.4 0.0 remarks VS android-lint-summaryPrettier display of Android Lint issues
Access the most powerful time series database as a service
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of remarks or a related project?
remarks — A DSL for marking student work
When judging student performance, it is useful to make both small, composable, quantitative judgements, and to collect qualitative remarks. This makes both spreadsheets and mere text-files ill-suited for marking student work. Although org-mode can solve this problem to a great extent, it becomes a heavy tool in the light of having to mark hundreds of students in a distributed, decentralized fashion. With org-mode, everything is in one file, while global, intra-student statistics are not needed until all the students have been fully marked.
- One, or several, human-readable/editable file(s) per student.
- git-friendly file format.
- Export options to spreadsheet-formats.
- Synchronization options with Dropbox and/or Google Drive.
Goal 4 is not necessarily related to
remarks, but is related to marking
student work with external examiners, who are not always willing to use more
explicit version-control systems, such as git.
remarks valid [<file>]checks that the file system structure is well-formed. For instance, checks that all total point sums are correct.
remarks check [<file>]like
validbut also ensures that all points have been given and sums correctly.
remarks show [<file>]checks the file system structure as above, and shows the overall judgement for each given argument.
remarks feedback [<file>]prints the accumulated feedback.
remarks summary [--depth <depth>] [<file>]checks and summarizes the points. Depth 0 (default) lists just the top-level judgements.
remarks pending [--depth <depth>] [<file>]shown the corrections that has not been completed. Can be cut at a given depth; depth 0 lists just the top-level judgements.
- Exporting remarks files:
remarks export [--format "<format>"] [<file>]exports corrections to a semicolon separated list. The format is a semicolon separated string of properties.
remarks exportHTML [<file>]exports all corrections to a dynamic html-table.
remarks exportResults [<file>]export results to a table with result of each sub question.
remarks exportMD [<file>]exports remarks to a MarkDown file
remarks exportPdfMark [<file>]export remarks to format that can be inserted as comments in PDf with GhostScript.
remarks parse [<file>]parses the given files and shows their ASTs.
remarks is written in Haskell. If you are new to Haskell, we can recommend
installing either Haskell Platform or The
Haskell Tool Stack. Follow
the instructions below to then install
remarks is on Hackage, so you
can use Cabal:
$ cabal install remarks
If you clone the repository, or download the sources, you get two further options:
- If you are using the purely functional package manager Nix, you can do this:
This will create a symlink
result, pointing to the directory in your Nix
store, containing the binary.
- Or, if using Stack, you can do this:
$ stack build $ stack install
.mrk file is a list of judgements.
A judgement starts with a header mark (a sequence of
#), a title
(followed by a
:), given points (followed by
/), and maximum
points (followed by a line break). The number of
# determines the
depth of the header, and every file must start at depth 1, but may
have multiple depth 1 judgements. Headings may be arbitrarily nested,
but must sum up correctly.
For instance, here is a file containing only quantitative remarks:
# Theory: 27/50 ## Question 1: 10/10 ## Question 2: 10/20 ## Question 3: 7/20 # Practice: 35/50 ## Task 1: 20/25 ## Task 2: 15/25
Sums of given points can be omitted in higher-level judgements, and
remarks will calculate these from points given to lower-level
judgements. For instance, we could omit the given points from
# Practice: /50 ## Task 1: 20/25 ## Task 2: 15/25
It is possible to indicate that a student did not submit an answer
- instead of a number points. This will be treated like
0 points. For instance:
# Theory: 17/50 ## Question 1: 10/10 ## Question 2: -/20 ## Question 3: 7/20
The header of a judgement may be followed by qualitative remarks. Remarks begin with an indent (two spaces), and a mood mark:
*for neutral/structural remarks;
+for positive remarks;
-for negative remarks;
~for mixed remarks;
?for impartial remarks.
Impartial remarks are good for judgements where the mood is left to be judged by a higher authority. For instance, when a teaching assistant is uncertain, and would like to let the teacher decide, or the solution cannot be used to make a judgement about this point.
Structural remarks are good for listing things to look for. For instance, a (template) judgement for an operating systems exercise might look something like this:
## T1: /15 ### Formal requirements: /5 * Has code * Has XML in a reloadable/testable form * Has an explanation ### Quality assessment: /10 * Understands semaphores * Understands deadlocks * Understands starvation * Avoids deadlocks * Avoids starvation * Avoids race conditions * Has a good degree of multiprogramming * Solves the problem ### Bonus: +0 * Has an accompanying implementation / simulation
Once filled in by a teaching assistant, this may look something like this:
## T1: 9/15 ### Formal requirements: 5/5 * Has code + Yes. * Has XML in a reloadable/testable form + Yes. * Has an explanation + Yes. ### Quality assessment: 2/10 * Understands semaphores - Seems to treat them as counters. Report doesn't talk about procuring or vacating at all. - Checks semaphore value directly. - Seems to have mixed up procure and vacate. * Understands deadlocks - If more than 5 cars arrive, then only 5 cars will be allowed to drive through, and everything will then deadlock. * Understands starvation ? Seems to, but this is hard to judge. * Avoids deadlocks ? See above. * Avoids starvation ? Can't judge this. * Avoids race conditions - Uses a busy loop in attempt to synchronize. - There is a race condition after the busy loop. * Has a good degree of multiprogramming + It's a ticket system, so it could be okay. * Solves the problem + In a complicated way, but yes. ### Bonus: +2 * Has an accompanying implementation / simulation + Yes!
Bonus-judgements must have the title
Bonus, but they don't have to be there
if you don't like them. The presence of bonus judgments also allows points to
sum up to more than the given maximum. This is regarded as a feature.
Points and Sums
You do not need to manually enter sums. Points are only required for the
bottom-most judgements. Given the template above you can do a
to check if all necessary points have been given. This makes a "pointless"
template a rather useful starting point for grading.
Points can be integers or half-points, that is, the number may end in
.5 is exactly representable in an IEEE-754 (the internal
representation of points), so no numerical imprecision occurs when dealing with
half-points. Maximum points may only be integers (the internal representation
of maximum points is still an IEEE-754 double to avoid numerical conversions).
Files and Directories
The file-format is kept "git-friendly" by keeping it comprehensible in plain-text, and allowing for independent marking by splitting the remarks for a student into multiple files.
The simplest setup is to have one
.mrk file per student (e.g.
To support more exotic setups,
remarks can also work with directories:
If supplied with a directory path,
remarkslooks for files ending in
.mrkinside that directory, and comprehends the files as above, in lexicographic filename order (e.g., [directory-with-mrk-files](samples/organization/directory-with-mrk-files)).
If there exists a directory
<basename>is recursively searched for further
.mrkfiles. Their contents is appended, in lexicographic filename order, to the last top-level judgement of
See the [organization samples](samples/organization) for some examples of how judgements may be structured using files and directories.
├── basic.mrk ├── directory-with-mrk-files │ ├── 01-theory.mrk │ └── 02-practice.mrk └── mixed-directory ├── 01-theory.mrk ├── 02-practice │ ├── Task1.mrk │ └── Task2.mrk └── 02-practice.mrk
mixed-directory all parse to the
same judgements. In particular, the output from the following
commands is identical:
$ cd samples/organization/ $ remarks parse basic.mrk $ remarks parse directory-with-mrk-files $ remarks parse mixed-directory
*Note that all licence references and agreements mentioned in the remarks README section above are relevant to that project's source code only.