Designing declarative software.

Factual Questions
1

There’s many tools and methodologies available to help programmers design software with object oriented languages. However, how are large pieces of declarative software, written in functional and logic languages, like Isabelle designed? Are there any methodologies specific to these languages?

2

I think this is a really cool question. I don’t have an answer, but I can pop this back up for a courtesy bump. :slight_smile:

3

I’m not sure that there’s anything particularly special to help design OO apps that wouldn’t be equally applicable to non-OO languages.

A fairly good percentage of C code is essentially object oriented, just where the coder is preserving the individuality of his objects rather than the compiler doing it for him.


struct Stack {
    void** items;
    size_t* item_sizes;
    int count;
    int top;
}

int stack_init(struct Stack* s, int start) {
    s->items = calloc(start, sizeof(void*));
    s->item_sizes = calloc(start, sizeof(size_t));
    if (!s->items || !s->item_sizes) return -1;
    s->count = start;
    s->top = -1;
    return 0;
}

void stack_cleanup(struct Stack* s) {
    free(s->items);
    free(s->item_sizes);
}

int stack_push(struct Stack* s, void* item, size_t size) {
    ++s->top;
    if (s->top >= s->count) {
        s->count <<= 1;
        s->items = realloc(s->items, s->count * sizeof(void*));
        s->item_sizes = realloc(s->item_sizes, s->count * sizeof(size_t));

        if (!s->items || !s->item_sizes) return -1;
    }

    s->items[s->top] = item;
    s->item_sizes[s->top] = size;

    return 0;
}

int stack_pop(struct Stack* s, void* out_item) {
    size_t ret_size;

    if (s->top < 0) {
        out_item = NULL;
        return 0;
    }

    out_item = s->items[s->top];
    ret_size = s->item_sizes[s->top];
    --s->top;

    return ret_size;
}

OO, at heart, pretty much just means that the compiler passes your data struct to all your functions for you.

4

Well, first we need to get the terms correct. Declarative, Functional, and Logical are three different types of programming languages. In the beginning, before Object Oriented programming, we had Top-Down design and we liked it!

5

Software design methodologies are intended to be language independent to the highest degree possible, so a lot of it’s just going to transfer over. I doubt that there’s much in the way of particular methods and tools for non-imperative languages for a couple reasons:

  1. In a lot of cases, the problem being approached is very formally specified, and the formalism dictates a large part of the system structure.

  2. Non-imperative languages aren’t widely used outside of academia right now. They’re very good tools to solve some problems, but those problems aren’t generally the sort that inspire whole industries. This may change as AI becomes more prevalent, but that’s probably not going to happen quickly.